Documentation

RockafellarSum_2026.ReasLib.FunctionalAnalysis.SequenceSpace.RationalTimeOperator.Parametrization.SeedSchedule

Fixed signed schedule for the S3 seed #

Natural index n represents source index n + 1. The signed coordinate label (q, b) represents a coordinate other than one and sign determined by b.

theorem Lorentz.exists_remote_unitDifference_norm_lt (q N : ℕ) (ε : ℝ) (hε : 0 < ε) :
∃ (j : ℕ), N < j ∧ ‖L1Seq.intervalCoordinateOperator (unitDifference q j)‖ < ε

Unit differences of arbitrarily small interval norm can be placed beyond any finite prefix.

noncomputable def Lorentz.seedSchedule :
RepeatingSchedule (ℕ × Bool)

A fixed repeating list of coordinate and sign labels.

Instances For
    def Lorentz.offAxisCoordinate (q : ℕ) :
    ℕ

    Enumerate every coordinate except the distinguished axis, including zero.

    Instances For
      noncomputable def Lorentz.seedCoordinate (n : ℕ) :
      ℕ

      The detected coordinate is always different from the distinguished axis.

      Instances For
        theorem Lorentz.exists_offAxisCoordinate_eq (i : ℕ) (hi : i ≠ 1) :
        ∃ (q : ℕ), offAxisCoordinate q = i

        Every off-axis coordinate is represented by a label.

        noncomputable def Lorentz.seedSign (n : ℕ) :
        ℝ

        The sign attached to the scheduled coordinate.

        Instances For
          noncomputable def Lorentz.seedTime (n : ℕ) :
          ℝ

          Source positive times, indexed from zero.

          Instances For
            noncomputable def Lorentz.seedRadius (n : ℕ) :
            ℝ

            Source perturbation radii, indexed from zero.

            Instances For
              theorem Lorentz.seedTime_pos (n : ℕ) :
              0 < seedTime n

              All seed positive times are strictly positive.

              theorem Lorentz.seedRadius_pos (n : ℕ) :

              All seed perturbation radii are strictly positive.

              theorem Lorentz.exists_seed_indices (n : ℕ) :
              ∃ (r : ℕ) (k : ℕ), max (n + 1) (seedCoordinate n) < r ∧ r < k ∧ seedTime n * ‖L1Seq.intervalCoordinateOperator (unitDifference 1 r)‖ < seedRadius n / 2 ∧ (↑n + 1) * ‖L1Seq.intervalCoordinateOperator (unitDifference (seedCoordinate n) k)‖ < seedRadius n / 2

              The two remote indices satisfy both source smallness budgets.

              noncomputable def Lorentz.seedBaseIndex (n : ℕ) :
              ℕ

              The chosen remote index of the bounded base point.

              Instances For
                noncomputable def Lorentz.seedDetectorIndex (n : ℕ) :
                ℕ

                The chosen remote index of the amplified detector.

                Instances For

                  The chosen indices retain their ordering and both quantitative budgets.

                  noncomputable def Lorentz.seedPoint (n : ℕ) :

                  The actual perturbed points of the source seed, with all choices fixed independently of any point tested against the polar.

                  Instances For
                    theorem Lorentz.seedBaseIndex_ne_one (n : ℕ) :

                    The selected base index is outside the distinguished coordinate.

                    The axis annihilates the selected detector's unit difference.

                    theorem Lorentz.abs_seedSign (n : ℕ) :
                    |seedSign n| = 1

                    The fixed schedule uses signs of absolute value one.

                    Every actual perturbed seed point has the prescribed dyadic positive time.

                    The actual seed points satisfy the source negative-coordinate radius bound.

                    theorem Lorentz.seedTime_bounds (n : ℕ) :
                    1 < seedTime n ∧ seedTime n ≤ 3 / 2

                    The positive times stay between one and three halves.

                    theorem Lorentz.seedRadius_lt_one (n : ℕ) :

                    The perturbation radii are uniformly less than one.

                    The actual seed point energies are positive and uniformly bounded by three.

                    theorem Lorentz.seedRadius_tendsto_zero :
                    Filter.Tendsto seedRadius Filter.atTop (nhds 0)

                    The geometric error scale tends to zero.

                    theorem Lorentz.seedTime_tendsto_one :
                    Filter.Tendsto seedTime Filter.atTop (nhds 1)

                    The positive times accumulate at one.

                    theorem Lorentz.negativeCoordinate_seedPoint_tendsto_zero :
                    Filter.Tendsto (fun (n : ℕ) => (negativeCoordinate axisDirection seed_axis_ne_zero) (seedPoint n)) Filter.atTop (nhds 0)

                    The actual seed points converge to zero in their negative coordinates.

                    theorem Lorentz.seedPoint_base_pairing_bound (w : C0Seq × L1Seq) (n : ℕ) :
                    |(C0Seq.symmetricForm w) ↑(axisSeedBase (seedTime n • unitDifference 1 (seedBaseIndex n)) (seedTime n))| ≤ 21 / 2 * (‖w.1‖ + ‖w.2‖)

                    The bounded bases of the actual scheduled points have a uniform pairing bound.

                    theorem Lorentz.seedRadius_add_lt_time_gap {i j : ℕ} (hij : i < j) :

                    The sum of perturbation radii is smaller than the gap of distinct positive times.

                    Distinct scheduled points satisfy the Lorentz Lipschitz estimate.

                    The difference of any two scheduled seed points has nonnegative pairing.

                    The set of actual scheduled detector perturbations is monotone.

                    theorem Lorentz.seedDetectorIndex_tendsto_atTop :
                    Filter.Tendsto seedDetectorIndex Filter.atTop Filter.atTop

                    Remote detector indices escape every finite prefix.

                    The unscaled detectors have vanishing interval coordinates.

                    theorem Lorentz.seedDetector_pairing_tendsto (x : C0Seq) (u : L1Seq) (q : ℕ) (b : Bool) :
                    Filter.Tendsto (fun (k : ℕ) => (C0Seq.symmetricForm (x, u)) ↑(unitDifferenceDetector axisDirection (seedCoordinate (seedSchedule.occurrence (q, b) k)) (seedDetectorIndex (seedSchedule.occurrence (q, b) k)))) Filter.atTop (nhds ((x + L1Seq.positiveOperator u) (offAxisCoordinate q)))

                    Along the fixed occurrence subsequence, the detector pairing converges to the corresponding residual coordinate.

                    theorem Lorentz.mem_axisCarrier_of_residual_zero (x : C0Seq) (u : L1Seq) (h : ∀ (i : ℕ), i ≠ 1 → (x + L1Seq.positiveOperator u) i = 0) :

                    Vanishing residual coordinates off the axis characterize the carrier.

                    theorem Lorentz.seedPoint_polar_scaled_pairing_le (w : C0Seq × L1Seq) (hw : ∀ (n : ℕ), 0 ≤ C0Seq.quadraticPairing (w - ↑(seedPoint n))) (n : ℕ) :
                    (↑n + 1) * seedSign n * (C0Seq.symmetricForm w) ↑(unitDifferenceDetector axisDirection (seedCoordinate n) (seedDetectorIndex n)) ≤ C0Seq.quadraticPairing w + 3 + 21 / 2 * (‖w.1‖ + ‖w.2‖)

                    Polar compatibility bounds the amplified detector reading uniformly.

                    theorem Lorentz.signed_residual_nonpos_of_seedPoint_polar (x : C0Seq) (u : L1Seq) (hw : ∀ (n : ℕ), 0 ≤ C0Seq.quadraticPairing ((x, u) - ↑(seedPoint n))) (q : ℕ) (b : Bool) :
                    (if b = true then 1 else -1) * (x + L1Seq.positiveOperator u) (offAxisCoordinate q) ≤ 0

                    Each signed residual coordinate of a point compatible with the scheduled seed points is nonpositive.

                    The monotone polar of the actual scheduled detector points lies in the axis carrier.

                    Every set containing the actual scheduled points has its polar inside the axis carrier, in particular the full half-line and anchor seed.

                    Each detector radius fits strictly below its distance from time one.

                    theorem Lorentz.seedRadius_le_one_div_128 (n : ℕ) :
                    seedRadius n ≤ 1 / 128

                    The radii are uniformly bounded by the first radius.