| import OAI.NumberTheory.TwoPoint.Circuits.CircuitQueryWalk |
|
|
| namespace OAI |
|
|
| /-! A query block is encoded by positions within its term, the path answers, |
| and one separator. Term indices are recovered from the modified restriction, |
| so the code alphabet is independent of the number of terms. -/ |
|
|
| namespace TwoPointCorrelations |
|
|
| open Finset |
| open scoped Classical |
|
|
| noncomputable def CubeTerm.slot {n : ℕ} (C : CubeTerm n) (i : Fin n) : ℕ := |
| if hi : i ∈ C.support then (C.support.equivFin ⟨i, hi⟩).val |
| else C.support.card |
|
|
| lemma CubeTerm.slot_le {n : ℕ} (C : CubeTerm n) (i : Fin n) : |
| C.slot i ≤ C.support.card := by |
| unfold slot |
| split_ifs with hi |
| · exact Nat.le_of_lt (Fin.isLt _) |
| · exact le_rfl |
|
|
| lemma CubeTerm.slot_injective {n : ℕ} (C : CubeTerm n) {i j : Fin n} |
| (hi : i ∈ C.support) (hj : j ∈ C.support) (h : C.slot i = C.slot j) : i = j := by |
| have he : C.support.equivFin ⟨i, hi⟩ = C.support.equivFin ⟨j, hj⟩ := by |
| apply Fin.ext |
| simpa only [slot, dite_eq_left hi, dite_eq_left hj] using h |
| exact congrArg Subtype.val (C.support.equivFin.injective he) |
|
|
| namespace DNFQueryBlock |
|
|
| noncomputable def literalCode {n : ℕ} (b : DNFQueryBlock n) : List (ℕ × Bool) := |
| (b.queried.sort (· ≤ ·)).map (fun i => (b.term.slot i, b.answer i)) |
|
|
| noncomputable def code {n : ℕ} (b : DNFQueryBlock n) : List (Option (ℕ × Bool)) := |
| b.literalCode.map some ++ [none] |
|
|
| noncomputable def codes {n : ℕ} (bs : List (DNFQueryBlock n)) : List (Option (ℕ × Bool)) := |
| bs.flatMap code |
|
|
| lemma code_length {n : ℕ} (b : DNFQueryBlock n) : b.code.length = b.queried.card + 1 := by |
| simp [code, literalCode, Finset.length_sort] |
|
|
| lemma literalCode_injective {n : ℕ} (C : CubeTerm n) (S T : Finset (Fin n)) |
| (hS : S ⊆ C.support) (hT : T ⊆ C.support) (x y : BooleanCube n) |
| (h : literalCode ⟨C, S, x⟩ = literalCode ⟨C, T, y⟩) : |
| S = T ∧ ∀ i ∈ S, x i = y i := by |
| have hmem (i : Fin n) (hi : i ∈ S) : i ∈ T ∧ x i = y i := by |
| have hc : (C.slot i, x i) ∈ literalCode ⟨C, S, x⟩ := by |
| apply List.mem_map.mpr |
| exact ⟨i, (Finset.mem_sort _).mpr hi, rfl⟩ |
| rw [h] at hc |
| obtain ⟨j, hj, he⟩ := List.mem_map.mp hc |
| have hjT : j ∈ T := (Finset.mem_sort _).mp hj |
| have hji : j = i := C.slot_injective (hT hjT) (hS hi) (congrArg Prod.fst he) |
| subst j |
| exact ⟨hjT, (congrArg Prod.snd he).symm⟩ |
| refine ⟨?_, fun i hi => (hmem i hi).2⟩ |
| apply Finset.Subset.antisymm (fun i hi => (hmem i hi).1) |
| intro i hi |
| have hc : (C.slot i, y i) ∈ literalCode ⟨C, T, y⟩ := by |
| apply List.mem_map.mpr |
| exact ⟨i, (Finset.mem_sort _).mpr hi, rfl⟩ |
| rw [← h] at hc |
| obtain ⟨j, hj, he⟩ := List.mem_map.mp hc |
| have hjS : j ∈ S := (Finset.mem_sort _).mp hj |
| have hji : j = i := C.slot_injective (hS hjS) (hT hi) (congrArg Prod.fst he) |
| exact hji ▸ hjS |
|
|
| end DNFQueryBlock |
|
|
| lemma separated_option_lists_injective {α : Type*} (xs ys : List α) |
| (u v : List (Option α)) |
| (h : xs.map some ++ none :: u = ys.map some ++ none :: v) : xs = ys ∧ u = v := by |
| induction xs generalizing ys with |
| | nil => |
| cases ys with |
| | nil => exact ⟨rfl, List.cons.inj h |>.2⟩ |
| | cons y ys => simp at h |
| | cons x xs ih => |
| cases ys with |
| | nil => simp at h |
| | cons y ys => |
| have hp := List.cons.inj h |
| have hxy : x = y := Option.some.inj hp.1 |
| obtain ⟨hxs, huv⟩ := ih ys hp.2 |
| exact ⟨by rw [hxy, hxs], huv⟩ |
|
|
| end TwoPointCorrelations |
|
|
| end OAI |
|
|
