| import OAI.Computability.MatchingCount.ParamRoutine |
|
|
| namespace OAI |
|
|
| section |
|
|
| namespace BinaryMatching.Raw |
| open Finset |
| abbrev Matrix (α : Type) := List (List α) |
| abbrev Cut := List Bool |
| abbrev Paths := List (Option (List ℕ)) |
|
|
| def nth {α : Type} [Inhabited α] (l : List α) (i : ℕ) : α := l[i]?.getD default |
| def get {α : Type} [Inhabited α] (a : Matrix α) (i j : ℕ) : α := nth (nth a i) j |
| def tab {α : Type} (n : ℕ) (f : ℕ → α) : List α := (List.range n).map f |
| def matrix {α : Type} (n : ℕ) (f : ℕ → ℕ → α) : Matrix α := tab n (fun i => tab n (f i)) |
| def view {α : Type} [Inhabited α] (n : ℕ) (a : Matrix α) : Fin n → Fin n → α := |
| fun i j => get a i.val j.val |
| def mem (S : Cut) (i : ℕ) : Bool := nth S i |
| def empty (n : ℕ) : Cut := List.replicate n false |
| def full (n : ℕ) : Cut := List.replicate n true |
| def inter (n : ℕ) (S T : Cut) : Cut := tab n (fun i => mem S i && mem T i) |
| def compl (n : ℕ) (S : Cut) : Cut := tab n (fun i => !mem S i) |
| def cardinal (S : Cut) : ℕ := (S.filter id).length |
|
|
| def vectorRep {n : ℕ} {α : Type} (f : Fin n → α) : List α := List.ofFn f |
| def matrixRep {n : ℕ} {α : Type} (f : Fin n → Fin n → α) : Matrix α := |
| vectorRep (fun i => vectorRep (f i)) |
| def cutRep {n : ℕ} (S : Finset (Fin n)) : Cut := vectorRep (fun i => decide (i∈S)) |
| def pathRep {n : ℕ} (p : ResidualSearch.Table n) : Paths := |
| vectorRep (fun i => (p i).map (List.map Fin.val)) |
|
|
| lemma tab_eq_ofFn {α : Type} (n : ℕ) (f : ℕ → α) : |
| tab n f=List.ofFn (fun i : Fin n => f i.val) := by |
| apply List.ext_getElem |
| · simp [tab] |
| · intro i hi hi' |
| simp [tab] |
|
|
| lemma range_eq_fin (n : ℕ) : List.range n=(List.finRange n).map Fin.val := by |
| have h := tab_eq_ofFn n id |
| simpa [tab,List.finRange,List.map_ofFn,Function.comp_def] using h |
|
|
| @[simp] lemma at_rep {n : ℕ} {α : Type} [Inhabited α] (f : Fin n → α) (i : Fin n) : |
| nth (vectorRep f) i.val=f i := by simp [nth,vectorRep,i.isLt] |
|
|
| @[simp] lemma get_rep {n : ℕ} {α : Type} [Inhabited α] (f : Fin n → Fin n → α) (i j : Fin n) : |
| get (matrixRep f) i.val j.val=f i j := by simp [get,matrixRep] |
|
|
| @[simp] lemma mem_rep {n : ℕ} (S : Finset (Fin n)) (i : Fin n) : |
| mem (cutRep S) i.val=decide (i∈S) := by simp [mem,cutRep] |
|
|
| lemma tab_eq_rep {n : ℕ} {α : Type} (g : ℕ → α) (f : Fin n → α) |
| (h : ∀ i,g i.val=f i) : tab n g=vectorRep f := by |
| rw [tab_eq_ofFn]; congr 1; funext i; exact h i |
| lemma matrix_eq_rep {n : ℕ} {α : Type} (g : ℕ → ℕ → α) (f : Fin n → Fin n → α) |
| (h : ∀ i j,g i.val j.val=f i j) : matrix n g=matrixRep f := by |
| apply tab_eq_rep |
| intro i |
| exact tab_eq_rep _ _ (h i) |
|
|
| lemma empty_rep (n : ℕ) : empty n=cutRep (∅:Finset (Fin n)) := by |
| simp [empty,cutRep,vectorRep] |
| lemma full_rep (n : ℕ) : full n=cutRep (univ:Finset (Fin n)) := by |
| simp [full,cutRep,vectorRep] |
| lemma inter_rep {n : ℕ} (S T : Finset (Fin n)) : |
| inter n (cutRep S) (cutRep T)=cutRep (S∩T) := by |
| apply tab_eq_rep |
| intro i |
| simp |
| lemma compl_rep {n : ℕ} (S : Finset (Fin n)) : compl n (cutRep S)=cutRep Sᶜ := by |
| apply tab_eq_rep |
| intro i |
| simp only [mem_rep,Finset.mem_compl,decide_not] |
| lemma cardinal_rep {n : ℕ} (S : Finset (Fin n)) : cardinal (cutRep S)=S.card := by |
| unfold cardinal cutRep vectorRep |
| have hh : List.ofFn (fun i : Fin n => decide (i∈S))= |
| (List.finRange n).map (fun i => decide (i∈S)) := by |
| simp [List.finRange,List.map_ofFn,Function.comp_def] |
| rw [hh] |
| rw [List.filter_map] |
| simp only [List.length_map] |
| rw [←List.toFinset_card_of_nodup ((List.nodup_finRange n).filter _)] |
| simp |
|
|
| lemma sum_tab {α : Type} [AddCommMonoid α] (n : ℕ) (f : ℕ → α) : |
| (tab n f).sum=∑ i : Fin n,f i.val := by rw [tab_eq_ofFn,List.sum_ofFn] |
|
|
| end BinaryMatching.Raw |
| end |
|
|
| end OAI |
|
|
