Documentation

MathlibNt.SieveTheory.Switching.ResidualComparison

Residual boundary comparisons and support screens #

Recursive residual-comparison predicates, ceil-division identities, and lower logarithmic screens reduce boundary densities to continuous residual masses. Partition faces and paired residual errors retain quantitative bounds.

All declarations retain the MathlibNt.SieveTheory.SwitchingPrinciple namespace.

A pointwise comparison interface for a residual upper Rosser chain inside a fixed bounding sieve. Besides the altered real level, it retains both invariants created by pair removal: the residual carrier stays in the ambient prime carrier and all of its logarithmic coordinates lie strictly below the inherited upper endpoint.

Equations
Instances For

    The residual comparison restricted to the screen and bounded level range that are preserved by pair removal. Unlike UpperRosserBoundaryResidualComparison, this is closed under the fixed-depth induction: a residual level is positive and no larger than its parent level, while its inherited upper face remains at most one.

    Equations
    Instances For

      A global residual comparison restricts to every screened bounded range.

      Increasing the lower-screen requirement only restricts the instances of a screened residual comparison.

      The residual comparison interface holds at depth zero with no error, for every altered real level and every ambiently supported carrier below its inherited upper endpoint.

      The exact depth-zero comparison is induction-ready on every bounded screened range.

      theorem MathlibNt.SieveTheory.SwitchingPrinciple.upperRosserBoundaryPair_outerLogCoordinate_mem {z Δ s b : } {q p₀ : } (hz : 1 < z) ( : 0 < Δ) (hs : s = Real.log Δ / Real.log z) (hqprime : Nat.Prime q) (hp₀prime : Nat.Prime p₀) (hqp₀ : q < p₀) (hp₀cube : p₀ ^ 3 < Δ⌋₊ + 1) (hp₀upper : Real.log p₀ / Real.log z < b) :
      Real.log p₀ / Real.log z Set.Ioc (Real.log q / Real.log z) (min b (s / 3)) Set.Iio b

      The outer prime exposed by one Buchstab pair lies in the exact inherited screen. The cubic Rosser condition gives the closed s / 3 face, while the residual carrier gives the strict inherited face b.

      theorem MathlibNt.SieveTheory.SwitchingPrinciple.UpperRosserBoundaryResidualComparison.ceilDiv {S : BoundingSieve} {z : } {q k : } {ε : } (hcomparison : UpperRosserBoundaryResidualComparison S z q k ε) {Δ s : } {p₀ p₁ : } {P : Finset } (hz : 1 < z) ( : 0 < Δ) (hs : s = Real.log Δ / Real.log z) (hqprime : Nat.Prime q) (hp₀prime : Nat.Prime p₀) (hp₁prime : Nat.Prime p₁) (hp₁₀ : p₁ < p₀) (hp₀cube : p₀ ^ 3 < Δ⌋₊ + 1) (hP : PS.prodPrimes.primeFactors) (hqs : qP) (hprime : pP, Nat.Prime p) (hqmin : pP, q p) (hupper : pP, p < p₁) :
      LinearSieve.upperRosserBoundaryChainsFixedDepthDensity (fun (p : ) => S.nu p / (1 - S.nu p)) ((Δ⌋₊ + 1) ⌈/⌉ (p₀ * p₁)) q P k LinearSieve.upperRosserBoundaryMassAux k (s - Real.log p₀ / Real.log z - Real.log p₁ / Real.log z) (Real.log q / Real.log z) (Real.log p₁ / Real.log z) + ε

      A residual comparison can be instantiated at the exact altered level left by peeling two primes. The ceiling-divided level and residual coordinate agree after the elementary logarithm identities; ambient support is inherited, and the strict carrier bound p < p₁ supplies the logarithmic upper face.

      theorem MathlibNt.SieveTheory.SwitchingPrinciple.UpperRosserBoundaryScreenedResidualComparison.ceilDiv {S : BoundingSieve} {z : } {q k : } {ε c s₁ : } (hcomparison : UpperRosserBoundaryScreenedResidualComparison S z q k ε c s₁) {Δ s : } {p₀ p₁ : } {P : Finset } (hz : 1 < z) ( : 0 < Δ) (hs : s = Real.log Δ / Real.log z) (hsUpper : s s₁) (hqprime : Nat.Prime q) (hp₀prime : Nat.Prime p₀) (hp₁prime : Nat.Prime p₁) (hp₁₀ : p₁ < p₀) (hp₀cube : p₀ ^ 3 < Δ⌋₊ + 1) (hp₁cut : p₁ z) (hP : PS.prodPrimes.primeFactors) (hqs : qP) (hprime : pP, Nat.Prime p) (hqmin : pP, q p) (hupper : pP, p < p₁) (hqscreen : c Real.log q / Real.log z) :
      LinearSieve.upperRosserBoundaryChainsFixedDepthDensity (fun (p : ) => S.nu p / (1 - S.nu p)) ((Δ⌋₊ + 1) ⌈/⌉ (p₀ * p₁)) q P k LinearSieve.upperRosserBoundaryMassAux k (s - Real.log p₀ / Real.log z - Real.log p₁ / Real.log z) (Real.log q / Real.log z) (Real.log p₁ / Real.log z) + ε

      A screened bounded residual comparison applies after peeling an admissible prime pair. The residual level decreases, and the second prime supplies an inherited face at most one whenever it lies below the ambient cutoff.

      theorem MathlibNt.SieveTheory.SwitchingPrinciple.upperRosserBoundaryChainsFixedDepthDensity_zero_le_boundaryMassAux_ceilDiv (nu : ) {z Δ s a b : } {q p₀ p₁ : } {P : Finset } (hz : 1 < z) ( : 0 < Δ) (hs : s = Real.log Δ / Real.log z) (ha : a = Real.log q / Real.log z) (hqprime : Nat.Prime q) (hp₀prime : Nat.Prime p₀) (hp₁prime : Nat.Prime p₁) (hp₁₀ : p₁ < p₀) (hp₀cube : p₀ ^ 3 < Δ⌋₊ + 1) (hqs : qP) (hqmin : pP, q p) :

      After peeling the first two selected primes, the ceiling-divided discrete depth-zero mass is bounded by the continuous mass at the exact residual logarithmic parameter. In particular, there is no rounding loss in the residual Rosser level.

      theorem MathlibNt.SieveTheory.SwitchingPrinciple.upperRosserBoundaryChainsFixedDepthDensity_one_le_residualBoundaryMassAux (nu : ) {z Δ s : } {q : } {P : Finset } (hz : 1 < z) ( : 0 < Δ) (hs : s = Real.log Δ / Real.log z) (hqs : qP) (hqprime : Nat.Prime q) (hprime : pP, Nat.Prime p) (hqmin : pP, q p) (hnu : pP, 0 nu p) :
      LinearSieve.upperRosserBoundaryChainsFixedDepthDensity nu (Δ⌋₊ + 1) q P 1 p₀P, p₁P with p₁ < p₀ p₀ ^ 3 < Δ⌋₊ + 1, nu p₀ * nu p₁ * LinearSieve.upperRosserBoundaryMassAux 0 (s - Real.log p₀ / Real.log z - Real.log p₁ / Real.log z) (Real.log q / Real.log z) (Real.log p₁ / Real.log z)

      Pointwise depth-one Buchstab majorant. Peeling the unique prime pair and using the exact depth-zero shell comparison leaves precisely the residual continuous indicator, with no local-product or rounding error.

      theorem MathlibNt.SieveTheory.SwitchingPrinciple.upperRosserBoundaryChainsFixedDepthDensity_one_le_screenedResidualBoundaryMassAux (nu : ) {z Δ s b : } {q : } {P : Finset } (hz : 1 < z) ( : 0 < Δ) (hs : s = Real.log Δ / Real.log z) (hqs : qP) (hqprime : Nat.Prime q) (hprime : pP, Nat.Prime p) (hqmin : pP, q p) (hupper : pP, Real.log p / Real.log z < b) (hnu : pP, 0 nu p) :
      LinearSieve.upperRosserBoundaryChainsFixedDepthDensity nu (Δ⌋₊ + 1) q P 1 p₀P with Real.log p₀ / Real.log z min b (s / 3), p₁P with p₁ < p₀ p₀ ^ 3 < Δ⌋₊ + 1, nu p₀ * nu p₁ * LinearSieve.upperRosserBoundaryMassAux 0 (s - Real.log p₀ / Real.log z - Real.log p₁ / Real.log z) (Real.log q / Real.log z) (Real.log p₁ / Real.log z)

      The pointwise depth-one majorant can be restricted to the exact inherited outer screen. The upper endpoint is closed because the cubic condition only implies x₀ ≤ s / 3; primes on that face must not be discarded.

      theorem MathlibNt.SieveTheory.SwitchingPrinciple.upperRosserBoundaryMassAux_ne_zero_outer_log_lower (k : ) {z Δ s : } {q p₀ p₁ : } (hz : 1 < z) ( : 0 < Δ) (hs : s = Real.log Δ / Real.log z) (hslo : 3 / 2 s) (hp₀prime : Nat.Prime p₀) (hp₁prime : Nat.Prime p₁) (hp₁₀ : p₁ < p₀) (hp₀cube : p₀ ^ 3 < Δ⌋₊ + 1) (hmass : LinearSieve.upperRosserBoundaryMassAux k (s - Real.log p₀ / Real.log z - Real.log p₁ / Real.log z) (Real.log q / Real.log z) (Real.log p₁ / Real.log z) 0) :
      1 / (2 * 3 ^ (k + 1)) < Real.log q / Real.log z

      The lower support exposed after peeling a Rosser pair is uniform at every fixed residual depth. The inherited upper bound is retained in the residual mass, while the lower bound depends only on that depth.

      theorem MathlibNt.SieveTheory.SwitchingPrinciple.upperRosserBoundaryMassAux_zero_ne_zero_outer_log_lower {z Δ s : } {q p₀ p₁ : } (hz : 1 < z) ( : 0 < Δ) (hs : s = Real.log Δ / Real.log z) (hslo : 3 / 2 s) (hp₀prime : Nat.Prime p₀) (hp₁prime : Nat.Prime p₁) (hp₁₀ : p₁ < p₀) (hp₀cube : p₀ ^ 3 < Δ⌋₊ + 1) (hmass : LinearSieve.upperRosserBoundaryMassAux 0 (s - Real.log p₀ / Real.log z - Real.log p₁ / Real.log z) (Real.log q / Real.log z) (Real.log p₁ / Real.log z) 0) :
      1 / 6 < Real.log q / Real.log z

      Every nonzero term in the continuous depth-zero majorant left after peeling the first Rosser pair has its distinguished-prime coordinate above 1 / 6. Unlike fixed-chain support, this applies after the discrete residual has already been enlarged to the continuous indicator.

      theorem MathlibNt.SieveTheory.SwitchingPrinciple.upperRosserBoundaryMassAux_le_fixedDepthScreen (k : ) {z Δ s : } {q p₀ p₁ : } (hz : 2 z) ( : 0 < Δ) (hs : s = Real.log Δ / Real.log z) (hslo : 3 / 2 s) (hp₀prime : Nat.Prime p₀) (hp₁prime : Nat.Prime p₁) (hp₁₀ : p₁ < p₀) (hp₀cube : p₀ ^ 3 < Δ⌋₊ + 1) (hp₁cut : p₁ z) :
      LinearSieve.upperRosserBoundaryMassAux k (s - Real.log p₀ / Real.log z - Real.log p₁ / Real.log z) (Real.log q / Real.log z) (Real.log p₁ / Real.log z) ((1 / (2 * 3 ^ (k + 1)))⁻¹ * (1 / (2 * 3 ^ (k + 1)))⁻¹) ^ k

      The recursive support screen gives a uniform bound for every residual mass at a fixed depth. This supplies the boundedness input for finite Darboux majorants independently of the sieve and of all prime coordinates.

      theorem MathlibNt.SieveTheory.SwitchingPrinciple.upperRosserBoundaryMassAux_ne_zero_outer_inner_log_lower (k : ) {z Δ s : } {q p₀ p₁ : } (hz : 1 < z) ( : 0 < Δ) (hs : s = Real.log Δ / Real.log z) (hslo : 3 / 2 s) (hqprime : Nat.Prime q) (hp₀prime : Nat.Prime p₀) (hp₁prime : Nat.Prime p₁) (hq₀ : q < p₀) (hq₁ : q < p₁) (hp₁₀ : p₁ < p₀) (hp₀cube : p₀ ^ 3 < Δ⌋₊ + 1) (hmass : LinearSieve.upperRosserBoundaryMassAux k (s - Real.log p₀ / Real.log z - Real.log p₁ / Real.log z) (Real.log q / Real.log z) (Real.log p₁ / Real.log z) 0) :
      1 / (2 * 3 ^ (k + 1)) < Real.log q / Real.log z 1 / (2 * 3 ^ (k + 1)) < Real.log p₀ / Real.log z 1 / (2 * 3 ^ (k + 1)) < Real.log p₁ / Real.log z

      All three exposed logarithmic coordinates of a nonzero fixed-depth residual lie above the same depth-dependent screen.

      theorem MathlibNt.SieveTheory.SwitchingPrinciple.upperRosserBoundaryMassAux_zero_ne_zero_outer_inner_log_lower {z Δ s : } {q p₀ p₁ : } (hz : 1 < z) ( : 0 < Δ) (hs : s = Real.log Δ / Real.log z) (hslo : 3 / 2 s) (hqprime : Nat.Prime q) (hp₀prime : Nat.Prime p₀) (hp₁prime : Nat.Prime p₁) (hq₀ : q < p₀) (hq₁ : q < p₁) (hp₁₀ : p₁ < p₀) (hp₀cube : p₀ ^ 3 < Δ⌋₊ + 1) (hmass : LinearSieve.upperRosserBoundaryMassAux 0 (s - Real.log p₀ / Real.log z - Real.log p₁ / Real.log z) (Real.log q / Real.log z) (Real.log p₁ / Real.log z) 0) :
      1 / 6 < Real.log q / Real.log z 1 / 6 < Real.log p₀ / Real.log z 1 / 6 < Real.log p₁ / Real.log z

      A nonzero residual after the first Rosser pair confines all three prime coordinates away from zero. The distinguished-prime inequality is the recursive cubic support; the other two follow from the ordering above q. This supplies a common lower cutoff for every depth-two logarithmic mesh.

      theorem MathlibNt.SieveTheory.SwitchingPrinciple.sum_mul_upperRosserBoundaryChainsFixedDepthDensity_one_le_residualBoundaryMass {S : BoundingSieve} {z Δ s : } (hz : 1 < z) ( : 0 < Δ) (hs : s = Real.log Δ / Real.log z) :
      qS.prodPrimes.primeFactors, S.nu q / (1 - S.nu q) * LinearSieve.upperRosserBoundaryChainsFixedDepthDensity (fun (p : ) => S.nu p / (1 - S.nu p)) (Δ⌋₊ + 1) q ({pS.prodPrimes.primeFactors | q < p}) 1 qS.prodPrimes.primeFactors, S.nu q / (1 - S.nu q) * p₀S.prodPrimes.primeFactors with q < p₀, p₁{pS.prodPrimes.primeFactors | q < p} with p₁ < p₀ p₀ ^ 3 < Δ⌋₊ + 1, S.nu p₀ / (1 - S.nu p₀) * (S.nu p₁ / (1 - S.nu p₁)) * LinearSieve.upperRosserBoundaryMassAux 0 (s - Real.log p₀ / Real.log z - Real.log p₁ / Real.log z) (Real.log q / Real.log z) (Real.log p₁ / Real.log z)

      The complete discrete depth-two contribution is bounded by the two peeled prime sums weighted by the continuous residual depth-zero mass. This is the exact finite majorant to which the two logarithmic partition estimates are applied.

      theorem MathlibNt.SieveTheory.SwitchingPrinciple.sum_mul_upperRosserBoundaryChainsFixedDepthDensity_succ_le_screenedResidualBoundaryMassAux_add (k : ) (E : ) {S : BoundingSieve} {z Δ s : } (hz : 2 z) ( : 0 < Δ) (hs : s = Real.log Δ / Real.log z) (hslo : 3 / 2 s) (hcut : pS.prodPrimes.primeFactors, p z) (hmajorant : q{qS.prodPrimes.primeFactors | 1 / (2 * 3 ^ (k + 1)) < Real.log q / Real.log z}, p₀{pS.prodPrimes.primeFactors | q < p}, p₁{p₁{pS.prodPrimes.primeFactors | q < p} | p₁ < p₀ p₀ ^ 3 < Δ⌋₊ + 1}, LinearSieve.upperRosserBoundaryChainsFixedDepthDensity (fun (p : ) => S.nu p / (1 - S.nu p)) ((Δ⌋₊ + 1) ⌈/⌉ (p₀ * p₁)) q ({p{pS.prodPrimes.primeFactors | q < p} | p < p₁}) k LinearSieve.upperRosserBoundaryMassAux k (s - Real.log p₀ / Real.log z - Real.log p₁ / Real.log z) (Real.log q / Real.log z) (Real.log p₁ / Real.log z) + E q p₀ p₁) :
      qS.prodPrimes.primeFactors, S.nu q / (1 - S.nu q) * LinearSieve.upperRosserBoundaryChainsFixedDepthDensity (fun (p : ) => S.nu p / (1 - S.nu p)) (Δ⌋₊ + 1) q ({pS.prodPrimes.primeFactors | q < p}) (k + 1) qS.prodPrimes.primeFactors with 1 / (2 * 3 ^ (k + 1)) < Real.log q / Real.log z, S.nu q / (1 - S.nu q) * p₀S.prodPrimes.primeFactors with q < p₀, p₁{pS.prodPrimes.primeFactors | q < p} with p₁ < p₀ p₀ ^ 3 < Δ⌋₊ + 1, S.nu p₀ / (1 - S.nu p₀) * (S.nu p₁ / (1 - S.nu p₁)) * (LinearSieve.upperRosserBoundaryMassAux k (s - Real.log p₀ / Real.log z - Real.log p₁ / Real.log z) (Real.log q / Real.log z) (Real.log p₁ / Real.log z) + E q p₀ p₁)

      Induction step for a fixed-depth boundary comparison. After screening the distinguished prime at the exact depth-dependent support, any pointwise majorant for the residual depth lifts through the exact two-prime recursion. The function E records the residual induction error without hiding how it is weighted by the two newly peeled coordinates.

      theorem MathlibNt.SieveTheory.SwitchingPrinciple.sum_mul_upperRosserBoundaryChainsFixedDepthDensity_succ_le_screenedResidualBoundaryMassAux (k : ) {S : BoundingSieve} {z Δ s : } (hz : 2 z) ( : 0 < Δ) (hs : s = Real.log Δ / Real.log z) (hslo : 3 / 2 s) (hcut : pS.prodPrimes.primeFactors, p z) (hmajorant : q{qS.prodPrimes.primeFactors | 1 / (2 * 3 ^ (k + 1)) < Real.log q / Real.log z}, p₀{pS.prodPrimes.primeFactors | q < p}, p₁{p₁{pS.prodPrimes.primeFactors | q < p} | p₁ < p₀ p₀ ^ 3 < Δ⌋₊ + 1}, LinearSieve.upperRosserBoundaryChainsFixedDepthDensity (fun (p : ) => S.nu p / (1 - S.nu p)) ((Δ⌋₊ + 1) ⌈/⌉ (p₀ * p₁)) q ({p{pS.prodPrimes.primeFactors | q < p} | p < p₁}) k LinearSieve.upperRosserBoundaryMassAux k (s - Real.log p₀ / Real.log z - Real.log p₁ / Real.log z) (Real.log q / Real.log z) (Real.log p₁ / Real.log z)) :
      qS.prodPrimes.primeFactors, S.nu q / (1 - S.nu q) * LinearSieve.upperRosserBoundaryChainsFixedDepthDensity (fun (p : ) => S.nu p / (1 - S.nu p)) (Δ⌋₊ + 1) q ({pS.prodPrimes.primeFactors | q < p}) (k + 1) qS.prodPrimes.primeFactors with 1 / (2 * 3 ^ (k + 1)) < Real.log q / Real.log z, S.nu q / (1 - S.nu q) * p₀S.prodPrimes.primeFactors with q < p₀, p₁{pS.prodPrimes.primeFactors | q < p} with p₁ < p₀ p₀ ^ 3 < Δ⌋₊ + 1, S.nu p₀ / (1 - S.nu p₀) * (S.nu p₁ / (1 - S.nu p₁)) * LinearSieve.upperRosserBoundaryMassAux k (s - Real.log p₀ / Real.log z - Real.log p₁ / Real.log z) (Real.log q / Real.log z) (Real.log p₁ / Real.log z)

      Error-free specialization of the fixed-depth recursion lift. It isolates the exact induction obligation: dominate every inherited residual carrier by upperRosserBoundaryMassAux k with its actual upper endpoint.

      theorem MathlibNt.SieveTheory.SwitchingPrinciple.sum_mul_upperRosserBoundaryChainsFixedDepthDensity_one_le_screenedResidualBoundaryMass {S : BoundingSieve} {z Δ s : } (hz : 1 < z) ( : 0 < Δ) (hs : s = Real.log Δ / Real.log z) (hslo : 3 / 2 s) :
      qS.prodPrimes.primeFactors, S.nu q / (1 - S.nu q) * LinearSieve.upperRosserBoundaryChainsFixedDepthDensity (fun (p : ) => S.nu p / (1 - S.nu p)) (Δ⌋₊ + 1) q ({pS.prodPrimes.primeFactors | q < p}) 1 qS.prodPrimes.primeFactors with 1 / 6 < Real.log q / Real.log z, S.nu q / (1 - S.nu q) * p₀{pS.prodPrimes.primeFactors | q < p} with 1 / 6 < Real.log p₀ / Real.log z, p₁{pS.prodPrimes.primeFactors | q < p} with p₁ < p₀ p₀ ^ 3 < Δ⌋₊ + 1 1 / 6 < Real.log p₁ / Real.log z, S.nu p₀ / (1 - S.nu p₀) * (S.nu p₁ / (1 - S.nu p₁)) * LinearSieve.upperRosserBoundaryMassAux 0 (s - Real.log p₀ / Real.log z - Real.log p₁ / Real.log z) (Real.log q / Real.log z) (Real.log p₁ / Real.log z)

      The exact depth-two residual majorant may be restricted to the compact box where all three logarithmic coordinates exceed 1 / 6. This is the screened finite sum to which the nested Darboux partitions are applied.

      theorem MathlibNt.SieveTheory.SwitchingPrinciple.sum_nu_div_one_sub_mul_upperRosserBoundaryMassAux_zero_le_rpow_Icc_add_atom {S : BoundingSieve} {K z s x₀ a u v η : } {T : Finset } (hlocal : HasDimensionOneLocalProductBound S K) (hz : 1 < z) (hu : 0 < u) (huv : u v) (hzu : 2 z ^ u) (hT : TS.prodPrimes.primeFactors) (hinterval : pT, z ^ u p p z ^ v) ( : 0 η) (hatom : pT, S.nu p / (1 - S.nu p) η) :
      pT, S.nu p / (1 - S.nu p) * LinearSieve.upperRosserBoundaryMassAux 0 (s - x₀ - Real.log p / Real.log z) a (Real.log p / Real.log z) v / u * (1 + K / (u * Real.log z)) - 1 + η

      One logarithmic cell of the inner p₁-sum in the depth-two residual majorant. The residual depth-zero mass is an indicator and hence is bounded by one. A possible prime on the closed right face is retained and paid for by the fixed-depth atom bound η.

      theorem MathlibNt.SieveTheory.SwitchingPrinciple.sum_nu_div_one_sub_mul_upperRosserBoundaryMassAux_zero_le_rpow_partition_Icc_add_atoms {ι : Type u_1} [Fintype ι] [DecidableEq ι] {S : BoundingSieve} {K z s x₀ a : } {T : Finset } {cell : ι} {u v η : ι} (hlocal : HasDimensionOneLocalProductBound S K) (hz : 1 < z) (hu : ∀ (i : ι), 0 < u i) (huv : ∀ (i : ι), u i v i) (hzu : ∀ (i : ι), 2 z ^ u i) (hT : TS.prodPrimes.primeFactors) (hinterval : pT, z ^ u (cell p) p p z ^ v (cell p)) ( : ∀ (i : ι), 0 η i) (hatom : pT, S.nu p / (1 - S.nu p) η (cell p)) :
      pT, S.nu p / (1 - S.nu p) * LinearSieve.upperRosserBoundaryMassAux 0 (s - x₀ - Real.log p / Real.log z) a (Real.log p / Real.log z) i : ι, (v i / u i * (1 + K / (u i * Real.log z)) - 1 + η i)

      Partitioned form of the inner p₁ residual estimate. It is the finite upper Darboux sum used for the inner integral in upperRosserBoundaryMass 1; every closed cell contributes its local-product increment and one fixed-depth atom error.

      theorem MathlibNt.SieveTheory.SwitchingPrinciple.sum_nu_div_one_sub_mul_upperRosserBoundaryMassAux_zero_le_rpow_partition_Icc_add_global_atoms {ι : Type u_1} [Fintype ι] [DecidableEq ι] {S : BoundingSieve} {K z s x₀ a η : } {T : Finset } {cell : ι} {u v : ι} (hlocal : HasDimensionOneLocalProductBound S K) (hz : 1 < z) (hu : ∀ (i : ι), 0 < u i) (huv : ∀ (i : ι), u i v i) (hzu : ∀ (i : ι), 2 z ^ u i) (hT : TS.prodPrimes.primeFactors) (hinterval : pT, z ^ u (cell p) p p z ^ v (cell p)) (hatom : pT with ¬p < z ^ v (cell p), S.nu p / (1 - S.nu p) η) :
      pT, S.nu p / (1 - S.nu p) * LinearSieve.upperRosserBoundaryMassAux 0 (s - x₀ - Real.log p / Real.log z) a (Real.log p / Real.log z) i : ι, (v i / u i * (1 + K / (u i * Real.log z)) - 1) + η

      Partitioned inner residual estimate with one global budget for every closed right-face atom. Since the depth-zero residual mass is an indicator, the weighted endpoint contribution is bounded by the unweighted normalized atom mass appearing in hatom.

      theorem MathlibNt.SieveTheory.SwitchingPrinciple.card_rpow_partition_right_faces_le {ι : Type u_1} [Fintype ι] [DecidableEq ι] {z : } {T : Finset } {cell : ι} {b : ι} (hupper : pT, p z ^ b (cell p)) :
      {pT | ¬p < z ^ b (cell p)}.card Fintype.card ι

      The union of all closed right faces of a logarithmic partition contains at most one natural number for each cell. This is the combinatorial reason that endpoint errors cost the size of the fixed mesh, rather than the number of primes being sieved.

      theorem MathlibNt.SieveTheory.SwitchingPrinciple.sum_rpow_partition_right_faces_le_card_mul {ι : Type u_1} [Fintype ι] [DecidableEq ι] {S : BoundingSieve} {z η : } {T : Finset } {cell : ι} {b : ι} {w : } ( : 0 η) (hupper : pT, p z ^ b (cell p)) (hatom : pT, w p * (S.nu p / (1 - S.nu p)) η) :
      pT with ¬p < z ^ b (cell p), w p * (S.nu p / (1 - S.nu p)) (Fintype.card ι) * η

      A pointwise atom bound yields one global budget for all right faces of a fixed logarithmic partition. In particular, the loss is controlled by the number of cells and is independent of the number of primes in the sieve.

      theorem MathlibNt.SieveTheory.SwitchingPrinciple.exists_rpow_partition_right_faces_mass_le (ι : Type u_1) [Fintype ι] [DecidableEq ι] (K ρ c : ) (hK : 1 K) ( : 0 < ρ) (hc : 0 < c) :
      ∃ (z₀ : ), 2 z₀ ∀ (S : BoundingSieve) (z : ) (T : Finset ) (cell : ι) (b : ι), z₀ zHasDimensionOneLocalProductBound S KTS.prodPrimes.primeFactors(∀ pT, z ^ c p)(∀ pT, p z ^ b (cell p))pT with ¬p < z ^ b (cell p), S.nu p / (1 - S.nu p) ρ

      For a fixed logarithmic mesh, all closed-face atoms are uniformly negligible under the dimension-one local-product hypothesis. The cutoff is independent of the sieve, the partition assignment, and the face locations.

      theorem MathlibNt.SieveTheory.SwitchingPrinciple.exists_weighted_sum_nu_div_one_sub_le_rpow_partition_Icc_add (ι : Type u_1) [Fintype ι] [DecidableEq ι] (K ρ B c : ) (hK : 1 K) ( : 0 < ρ) (hB : 0 B) (hc : 0 < c) :
      ∃ (z₀ : ), 2 z₀ ∀ (S : BoundingSieve) (z : ) (T : Finset ) (w : ) (cell : ι) (u v M : ι), z₀ zHasDimensionOneLocalProductBound S K(∀ (i : ι), c u i)(∀ (i : ι), u i v i)TS.prodPrimes.primeFactors(∀ pT, z ^ u (cell p) p p z ^ v (cell p))(∀ (i : ι), 0 M i)(∀ pT, 0 w p w p M (cell p))(∀ pT, w p B)pT, w p * (S.nu p / (1 - S.nu p)) i : ι, M i * (v i / u i * (1 + K / (u i * Real.log z)) - 1) + ρ

      Uniform weighted Stieltjes comparison on an arbitrary fixed positive logarithmic screen and an arbitrary finite closed partition. This is the depth-independent form of the screened comparison: the lower screen c, the cell geometry, and the weight majorants are all parameters.

      theorem MathlibNt.SieveTheory.SwitchingPrinciple.sum_nu_div_one_sub_le_of_log_coordinate_lower {S : BoundingSieve} {K z c : } {P : Finset } (hlocal : HasDimensionOneLocalProductBound S K) (hz : 1 < z) (hc1 : c 1) (hzc : 2 z ^ c) (hP : PS.prodPrimes.primeFactors) (hcut : pP, p z) (hscreen : pP, c Real.log p / Real.log z) :
      pP, S.nu p / (1 - S.nu p) Real.log (z + 1) / Real.log (z ^ c) * (1 + K / Real.log (z ^ c)) - 1

      The normalized prime mass above a fixed positive logarithmic screen is bounded by one dimension-one local-product interval.

      theorem MathlibNt.SieveTheory.SwitchingPrinciple.sum_pair_mul_residual_error_le_of_uniform (E : ) {S : BoundingSieve} {K z c ε : } {D : } {P : Finset } (hlocal : HasDimensionOneLocalProductBound S K) (hz : 1 < z) (hc1 : c 1) (hzc : 2 z ^ c) ( : 0 ε) (hP : PS.prodPrimes.primeFactors) (hcut : pP, p z) (hscreen : pP, c Real.log p / Real.log z) (hE : p₀P, p₁{p₁P | p₁ < p₀ p₀ ^ 3 < D}, 0 E p₀ p₁ E p₀ p₁ ε) :
      p₀P, p₁P with p₁ < p₀ p₀ ^ 3 < D, S.nu p₀ / (1 - S.nu p₀) * (S.nu p₁ / (1 - S.nu p₁)) * E p₀ p₁ ε * (Real.log (z + 1) / Real.log (z ^ c) * (1 + K / Real.log (z ^ c)) - 1) ^ 2

      A uniform pointwise residual error remains quantitative after both peeled prime sums. On a fixed positive logarithmic screen it costs at most the square of the one-dimensional normalized prime mass bound.