File size: 4,568 Bytes
e5a97c6 | 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 | import OAI.Combinatorics.LowSpaceSubsetSum.Streams.CyclicCursor
import OAI.Combinatorics.LowSpaceSubsetSum.Streams.BinaryPivot
namespace OAI
/-!
# Executable modular row initialization
Binary search finds the first direct pivot and the position after the last
complementary pivot. The resulting constant-state cyclic cursor produces
the corresponding sorted modular row exactly. The cutoff search uses a
supplied number of steps; the theorem requires only that the array length
be smaller than `2^k`. Equal residues stay separate array occurrences.
-/
namespace LowSpaceSubsetSum
namespace ModularCursor
open scoped Fin.NatCast
variable {n : ℕ} [NeZero n] {α : Type*}
def forwardStart (a : Fin n → α) (residue : α → ℤ) (P r : ℤ) (k : ℕ) :
CyclicCursor.State n :=
⟨Fin.ofNat n (BinaryPivot.search (fun i => decide (residue (a i) < P - r)) k).lo,
n, false⟩
def reverseStart (a : Fin n → α) (residue : α → ℤ) (K : ℤ) (k : ℕ) :
CyclicCursor.State n :=
⟨Fin.ofNat n (BinaryPivot.search (fun i => decide (residue (a i) ≤ K)) k).lo - 1,
n, true⟩
theorem forward_trace (a : Fin n → α) (residue : α → ℤ) (P r : ℤ) (k : ℕ)
(hk : n < 2 ^ k) (hsort : Monotone (fun i => residue (a i))) :
CyclicCursor.trace a n (forwardStart a residue P r k) =
ModularRows.direct P r residue (List.ofFn a) := by
have hprefix : BinaryPivot.PrefixPredicate
(fun i : Fin n => decide (residue (a i) < P - r)) := by
intro i j hij hj
apply decide_eq_true
exact lt_of_le_of_lt (hsort hij) (of_decide_eq_true hj)
have hsplit := BinaryPivot.search_split a
(fun x => decide (residue x < P - r)) hprefix k hk
let c := BinaryPivot.search (fun i : Fin n => decide (residue (a i) < P - r)) k
let lo := (List.ofFn a).take c.lo
let hi := (List.ofFn a).drop c.lo
have hc : c.lo ≤ n := c.ordered.trans c.bounded
have hlist : List.ofFn a = lo ++ hi := (List.take_append_drop c.lo _).symm
apply CyclicCursor.forward_trace_eq_direct a P r residue lo hi hlist
(Fin.ofNat n c.lo)
· simp [lo, hc]
· simpa only [decide_eq_true_eq] using hsplit.1
· simpa only [decide_eq_false_iff_not, not_lt] using hsplit.2
theorem reverse_trace (a : Fin n → α) (residue : α → ℤ) (K : ℤ) (k : ℕ)
(hk : n < 2 ^ k) (hsort : Monotone (fun i => residue (a i))) :
CyclicCursor.trace a n (reverseStart a residue K k) =
ModularRows.complementary K residue (List.ofFn a) := by
have hprefix : BinaryPivot.PrefixPredicate
(fun i : Fin n => decide (residue (a i) ≤ K)) := by
intro i j hij hj
apply decide_eq_true
exact (hsort hij).trans (of_decide_eq_true hj)
have hsplit := BinaryPivot.search_split a
(fun x => decide (residue x ≤ K)) hprefix k hk
let c := BinaryPivot.search (fun i : Fin n => decide (residue (a i) ≤ K)) k
let lo := (List.ofFn a).take c.lo
let hi := (List.ofFn a).drop c.lo
have hc : c.lo ≤ n := c.ordered.trans c.bounded
have hlist : List.ofFn a = lo ++ hi := (List.take_append_drop c.lo _).symm
apply CyclicCursor.reverse_trace_eq_complementary a K residue lo hi hlist
(Fin.ofNat n c.lo)
· simp [lo, hc]
· simpa only [decide_eq_true_eq] using hsplit.1
· simpa only [decide_eq_false_iff_not, not_le] using hsplit.2
theorem forward_sorted (a : Fin n → α) (residue : α → ℤ) (P r : ℤ) (k : ℕ)
(hk : n < 2 ^ k) (hsort : Monotone (fun i => residue (a i)))
(hr : 0 ≤ r) (hrP : r < P) (hbound : ∀ i, 0 ≤ residue (a i) ∧ residue (a i) < P) :
(CyclicCursor.trace a n (forwardStart a residue P r k)).Pairwise
(fun x y => (r + residue x) % P ≤ (r + residue y) % P) := by
rw [forward_trace a residue P r k hk hsort]
apply ModularRows.direct_sorted hr hrP
· intro x hx
obtain ⟨i, rfl⟩ := List.mem_ofFn.mp hx
exact hbound i
· exact List.pairwise_ofFn.mpr (fun _ _ h => hsort h.le)
theorem reverse_sorted (a : Fin n → α) (residue : α → ℤ) (P K : ℤ) (k : ℕ)
(hk : n < 2 ^ k) (hsort : Monotone (fun i => residue (a i)))
(hK : 0 ≤ K) (hKP : K < P) (hbound : ∀ i, 0 ≤ residue (a i) ∧ residue (a i) < P) :
(CyclicCursor.trace a n (reverseStart a residue K k)).Pairwise
(fun x y => (K - residue x) % P ≤ (K - residue y) % P) := by
rw [reverse_trace a residue K k hk hsort]
apply ModularRows.complementary_sorted hK hKP
· intro x hx
obtain ⟨i, rfl⟩ := List.mem_ofFn.mp hx
exact hbound i
· exact List.pairwise_ofFn.mpr (fun _ _ h => hsort h.le)
end ModularCursor
end LowSpaceSubsetSum
end OAI
|