File size: 5,116 Bytes
5d5048e | 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.Combinatorics.LowSpaceSubsetSum.Representation.RepresentationExtraPrime
import Mathlib.Algebra.Order.Floor.Semifield
namespace OAI
/-! # Exact integer computation of the representation parameters
Distinct-sum counts determine the ordering and low-prime bit lengths.
Logarithms remain analysis quantities and are not evaluated by the program.
-/
namespace LowSpaceSubsetSum
/-- Sort by decreasing distinct-sum count, with the same index tie rule as
the deficiency ordering in the analysis. -/
def mixerOrderFromCounts (counts : Fin 3 → ℕ) : Equiv.Perm (Fin 3) :=
Tuple.sort (fun i => -(counts i : ℤ))
/-- The floor of the rational cutoff, with natural truncation at zero. -/
def rationalLowParameter (n half : ℕ) : ℕ :=
((5000 * (half : ℤ) - 39 * n) / 5000).toNat
def lowParameterFromCount (n half count : ℕ) : ℕ :=
max (rationalLowParameter n half) (Nat.log2 count / 2)
def extraParameterFromLow (n m : ℕ) (low : Fin 3 → ℕ) : ℕ :=
((125 * (n : ℤ) - 234 * m + 500 * min (low 0) (min (low 1) (low 2))) / 500).toNat
theorem rationalLowParameter_eq (n half : ℕ) :
rationalLowParameter n half = ⌊(half : ℝ) - (39 / 5000 : ℝ) * n⌋₊ := by
rw [rationalLowParameter, ← Int.floor_toNat]
congr 1
have he : (half : ℝ) - (39 / 5000 : ℝ) * n =
((5000 * (half : ℤ) - 39 * n : ℤ) : ℝ) / (5000 : ℕ) := by
push_cast
ring
rw [he, Int.floor_div_natCast, Int.floor_intCast]
norm_num
theorem floor_half_logb_count (count : ℕ) :
⌊Real.logb 2 (count : ℝ) / 2⌋₊ = Nat.log2 count / 2 := by
rw [Nat.floor_div_ofNat]
have hl := Real.natFloor_logb_natCast 2 count
norm_num only [Nat.cast_ofNat] at hl
rw [hl, Nat.log2_eq_log_two]
private theorem sort_eq_of_le_iff {α β : Type*} [LinearOrder α] [LinearOrder β]
(f : Fin 3 → α) (g : Fin 3 → β)
(h : ∀ i j, f i ≤ f j ↔ g i ≤ g j) : Tuple.sort f = Tuple.sort g := by
apply Tuple.eq_sort_iff.mpr
obtain ⟨hm, ht⟩ := (Tuple.eq_sort_iff (f := f) (σ := Tuple.sort f)).mp rfl
constructor
· intro i j hij
exact (h _ _).mp (hm hij)
· intro i j hij he
apply ht i j hij
exact le_antisymm ((h _ _).mpr he.le) ((h _ _).mpr he.ge)
namespace RepresentationSetup
variable {n : ℕ} (R : RepresentationSetup n)
theorem rawMixers_card_mixerSize (z : Layout n) (i : Fin 3) :
(R.rawMixers z i).card = mixerSize n := by
rw [rawMixers, permuteSubset_card, R.card]
theorem mixerOrder_eq_integer (z : Layout n) :
R.mixerOrder z = mixerOrderFromCounts
(fun i => distinctSumCount R.originalWeights (R.rawMixers z i)) := by
unfold mixerOrder mixerOrderFromCounts
apply sort_eq_of_le_iff
intro i j
have hi := distinctSumCount_pos_real R.originalWeights (R.rawMixers z i)
have hj := distinctSumCount_pos_real R.originalWeights (R.rawMixers z j)
have hl := Real.logb_le_logb (by norm_num : (1 : ℝ) < 2) hj hi
simp only [deficiency, R.rawMixers_card_mixerSize]
rw [sub_le_sub_iff_left, hl, neg_le_neg_iff]
exact_mod_cast Iff.rfl
/-- The exact floor of each low exponent is computed by integer arithmetic
and the bit length of the distinct-sum count. -/
theorem floor_lowExponent_eq_integer (z : Layout n) (i : Fin 3) :
⌊R.lowExponent z i⌋₊ = lowParameterFromCount n R.halfSize
(distinctSumCount R.originalWeights (R.orderedMixers z i)) := by
have hc : (R.orderedMixers z i).card = 2 * R.halfSize := R.orderedMixers_card z i
have hcR : ((R.orderedMixers z i).card : ℝ) = 2 * R.halfSize := by exact_mod_cast hc
have he : R.lowExponent z i = max
((R.halfSize : ℝ) - (39 / 5000 : ℝ) * n)
(Real.logb 2 (distinctSumCount R.originalWeights (R.orderedMixers z i)) / 2) := by
unfold lowExponent deficiency
rw [hcR, ← max_sub_sub_left]
congr 1
ring
rw [he, lowParameterFromCount, rationalLowParameter_eq, ← floor_half_logb_count]
exact Nat.floor_mono.map_max
theorem extraPrimeParameter_eq_integer (z : Layout n) :
R.extraPrimeParameter z = extraParameterFromLow n (mixerSize n)
(fun i => lowParameterFromCount n R.halfSize
(distinctSumCount R.originalWeights (R.orderedMixers z i))) := by
simp only [extraPrimeParameter, R.floor_lowExponent_eq_integer]
let k := min
(lowParameterFromCount n R.halfSize
(distinctSumCount R.originalWeights (R.orderedMixers z 0)))
(min (lowParameterFromCount n R.halfSize
(distinctSumCount R.originalWeights (R.orderedMixers z 1)))
(lowParameterFromCount n R.halfSize
(distinctSumCount R.originalWeights (R.orderedMixers z 2))))
change ⌊(n : ℝ) / 4 + (4 / 125 : ℝ) * mixerSize n -
(mixerSize n : ℝ) / 2 + k⌋₊ =
((125 * (n : ℤ) - 234 * mixerSize n + 500 * k) / 500).toNat
rw [← Int.floor_toNat]
congr 1
have he : (n : ℝ) / 4 + (4 / 125 : ℝ) * mixerSize n -
(mixerSize n : ℝ) / 2 + k =
((125 * (n : ℤ) - 234 * mixerSize n + 500 * k : ℤ) : ℝ) / (500 : ℕ) := by
push_cast
ring
rw [he, Int.floor_div_natCast, Int.floor_intCast]
norm_num
end RepresentationSetup
end LowSpaceSubsetSum
end OAI
|