| import Mathlib.Data.List.Pairwise |
| import Mathlib.Data.List.Perm.Basic |
| import Mathlib.Data.Int.ModEq |
| import Mathlib.Tactic |
|
|
| namespace OAI |
|
|
| /-! |
| # The modular pivot order of a pair-stream row |
|
|
| These are the two cyclic orders in `lem:streams`. The list is an analysis view |
| of one sorted slice: implementation can traverse the slice by its pivot and |
| cursor, rather than allocating the reordered list. The permutation theorems |
| preserve occurrence multiplicity, including repeated residues. |
| -/ |
|
|
| namespace LowSpaceSubsetSum |
| namespace ModularRows |
|
|
| variable {α : Type*} |
|
|
| def direct (P r : ℤ) (residue : α → ℤ) (xs : List α) : List α := |
| xs.filter (fun x => decide (P - r ≤ residue x)) ++ |
| xs.filter (fun x => decide (residue x < P - r)) |
|
|
| def complementary (K : ℤ) (residue : α → ℤ) (xs : List α) : List α := |
| (xs.filter (fun x => decide (residue x ≤ K))).reverse ++ |
| (xs.filter (fun x => decide (K < residue x))).reverse |
|
|
| theorem direct_perm (P r : ℤ) (residue : α → ℤ) (xs : List α) : |
| (direct P r residue xs).Perm xs := by |
| simpa only [direct, ← decide_not, not_le] using |
| List.filter_append_perm (fun x => decide (P - r ≤ residue x)) xs |
|
|
| theorem complementary_perm (K : ℤ) (residue : α → ℤ) (xs : List α) : |
| (complementary K residue xs).Perm xs := by |
| apply ((List.reverse_perm _).append (List.reverse_perm _)).trans |
| simpa only [← decide_not, not_le] using List.filter_append_perm (fun x => decide (residue x ≤ K)) xs |
|
|
| theorem direct_wrapped {P r x : ℤ} (_hr : 0 ≤ r) (hrP : r < P) |
| (_hx : 0 ≤ x) (hxP : x < P) (hwrap : P - r ≤ x) : |
| (r + x) % P = r + x - P := by |
| rw [← Int.sub_emod_right (r + x) P] |
| exact Int.emod_eq_of_lt (by omega) (by omega) |
|
|
| theorem direct_unwrapped {P r x : ℤ} (hr : 0 ≤ r) |
| (hx : 0 ≤ x) (hwrap : x < P - r) : (r + x) % P = r + x := |
| Int.emod_eq_of_lt (by omega) (by omega) |
|
|
| theorem complementary_low {P K x : ℤ} (_hK : 0 ≤ K) (hKP : K < P) |
| (hx : 0 ≤ x) (hsmall : x ≤ K) : (K - x) % P = K - x := |
| Int.emod_eq_of_lt (by omega) (by omega) |
|
|
| theorem complementary_high {P K x : ℤ} (hK : 0 ≤ K) (_hKP : K < P) |
| (hxP : x < P) (hlarge : K < x) : (K - x) % P = K - x + P := by |
| rw [← Int.add_emod_right (K - x) P] |
| exact Int.emod_eq_of_lt (by omega) (by omega) |
|
|
| /-- Direct cyclic traversal is sorted by normalized pair residue. -/ |
| theorem direct_sorted {P r : ℤ} (hr : 0 ≤ r) (hrP : r < P) |
| (residue : α → ℤ) (xs : List α) |
| (hbound : ∀ x ∈ xs, 0 ≤ residue x ∧ residue x < P) |
| (hsort : xs.Pairwise (fun x y => residue x ≤ residue y)) : |
| (direct P r residue xs).Pairwise |
| (fun x y => (r + residue x) % P ≤ (r + residue y) % P) := by |
| apply List.pairwise_append.mpr |
| refine ⟨?_, ?_, ?_⟩ |
| · apply (hsort.filter (fun x => decide (P - r ≤ residue x))).imp_of_mem |
| intro x y hx hy hxy |
| obtain ⟨hxmem, hxwrap⟩ := List.mem_filter.mp hx |
| obtain ⟨hymem, hywrap⟩ := List.mem_filter.mp hy |
| have hxw : P - r ≤ residue x := of_decide_eq_true hxwrap |
| have hyw : P - r ≤ residue y := of_decide_eq_true hywrap |
| rw [direct_wrapped hr hrP (hbound x hxmem).1 (hbound x hxmem).2 hxw, |
| direct_wrapped hr hrP (hbound y hymem).1 (hbound y hymem).2 hyw] |
| omega |
| · apply (hsort.filter (fun x => decide (residue x < P - r))).imp_of_mem |
| intro x y hx hy hxy |
| obtain ⟨hxmem, hxwrap⟩ := List.mem_filter.mp hx |
| obtain ⟨hymem, hywrap⟩ := List.mem_filter.mp hy |
| rw [direct_unwrapped hr (hbound x hxmem).1 (of_decide_eq_true hxwrap), |
| direct_unwrapped hr (hbound y hymem).1 (of_decide_eq_true hywrap)] |
| omega |
| · intro x hx y hy |
| obtain ⟨hxmem, hxwrap⟩ := List.mem_filter.mp hx |
| obtain ⟨hymem, hywrap⟩ := List.mem_filter.mp hy |
| rw [direct_wrapped hr hrP (hbound x hxmem).1 (hbound x hxmem).2 |
| (of_decide_eq_true hxwrap), |
| direct_unwrapped hr (hbound y hymem).1 (of_decide_eq_true hywrap)] |
| have := (hbound x hxmem).2 |
| have := (hbound y hymem).1 |
| omega |
|
|
| /-- Reverse cyclic traversal is sorted by the complementary residue. -/ |
| theorem complementary_sorted {P K : ℤ} (hK : 0 ≤ K) (hKP : K < P) |
| (residue : α → ℤ) (xs : List α) |
| (hbound : ∀ x ∈ xs, 0 ≤ residue x ∧ residue x < P) |
| (hsort : xs.Pairwise (fun x y => residue x ≤ residue y)) : |
| (complementary K residue xs).Pairwise |
| (fun x y => (K - residue x) % P ≤ (K - residue y) % P) := by |
| apply List.pairwise_append.mpr |
| refine ⟨?_, ?_, ?_⟩ |
| · apply List.pairwise_reverse.mpr |
| apply (hsort.filter (fun x => decide (residue x ≤ K))).imp_of_mem |
| intro x y hx hy hxy |
| obtain ⟨hxmem, hxsmall⟩ := List.mem_filter.mp hx |
| obtain ⟨hymem, hysmall⟩ := List.mem_filter.mp hy |
| rw [complementary_low hK hKP (hbound x hxmem).1 (of_decide_eq_true hxsmall), |
| complementary_low hK hKP (hbound y hymem).1 (of_decide_eq_true hysmall)] |
| omega |
| · apply List.pairwise_reverse.mpr |
| apply (hsort.filter (fun x => decide (K < residue x))).imp_of_mem |
| intro x y hx hy hxy |
| obtain ⟨hxmem, hxlarge⟩ := List.mem_filter.mp hx |
| obtain ⟨hymem, hylarge⟩ := List.mem_filter.mp hy |
| rw [complementary_high hK hKP (hbound x hxmem).2 (of_decide_eq_true hxlarge), |
| complementary_high hK hKP (hbound y hymem).2 (of_decide_eq_true hylarge)] |
| omega |
| · intro x hx y hy |
| obtain ⟨hxmem, hxsmall⟩ := List.mem_filter.mp (List.mem_reverse.mp hx) |
| obtain ⟨hymem, hylarge⟩ := List.mem_filter.mp (List.mem_reverse.mp hy) |
| rw [complementary_low hK hKP (hbound x hxmem).1 (of_decide_eq_true hxsmall), |
| complementary_high hK hKP (hbound y hymem).2 (of_decide_eq_true hylarge)] |
| have := (hbound x hxmem).1 |
| have := (hbound y hymem).2 |
| omega |
|
|
| /-- Filtering a row by the small modulus preserves its residue ordering. -/ |
| theorem filtered_sorted (p c : ℤ) (weight residue : α → ℤ) (xs : List α) |
| (hsort : xs.Pairwise (fun x y => residue x ≤ residue y)) : |
| (xs.filter (fun x => decide (weight x % p = c % p))).Pairwise |
| (fun x y => residue x ≤ residue y) := hsort.filter _ |
|
|
| end ModularRows |
| end LowSpaceSubsetSum |
|
|
| end OAI |
|
|
