| import OAI.Computability.WLIdentification.DimensionDecider |
|
|
| namespace OAI |
|
|
| namespace WLIdentification |
| /- Polynomially presented finite types. Membership refers to actual natural |
| codes and all iteration bounds have literal unary word realizers. -/ |
| namespace FinitePresentation |
| open WordExpressions |
|
|
| structure Presented (A : Word → Type) where |
| code : (w : Word) → A w ↪ ℕ |
| bound : Word → ℕ |
| good : Word → ℕ → Bool |
| code_lt : ∀ w x, code w x < bound w |
| good_iff : ∀ w i, good w i = true ↔ ∃ x, code w x = i |
| bound_poly : NatPoly (fun S : Fin 1 → Word => bound (S 0)) |
| good_poly : BoolPoly (fun S : Fin 2 → Word => good (S 0) (S 1).length) |
|
|
| namespace Presented |
| variable {A B : Word → Type} |
|
|
| @[simp] theorem good_code (P : Presented A) (w : Word) (x : A w) : P.good w (P.code w x)=true := |
| (P.good_iff w _).mpr ⟨x,rfl⟩ |
|
|
| theorem good_lt (P : Presented A) {w : Word} {i : ℕ} (h : P.good w i=true) : i<P.bound w := by |
| obtain ⟨x,rfl⟩ := (P.good_iff w i).mp h |
| exact P.code_lt w x |
|
|
| theorem bound_poly_of (P : Presented A) {n} {w : (Fin n → Word) → Word} (hw : WordExpressions.Poly w) : |
| NatPoly (fun S => P.bound (w S)) := by |
| exact P.bound_poly.subst (g := fun _ => w) (fun _ => hw) |
|
|
| theorem good_poly_of (P : Presented A) {n} {w : (Fin n → Word) → Word} {i : (Fin n → Word) → ℕ} |
| (hw : WordExpressions.Poly w) (hi : NatPoly i) : BoolPoly (fun S => P.good (w S) (i S)) := by |
| have h := P.good_poly.subst (g := ![w, fun S => unary (i S)]) (by intro i; fin_cases i; exacts [hw,hi]) |
| simpa [unary] using h |
|
|
| noncomputable def fixed (A : Type) [Fintype A] : Presented (fun _ => A) where |
| code _ := NaturalCode.fixed A |
| bound _ := Fintype.card A |
| good _ i := decide (i<Fintype.card A) |
| code_lt _ x := (Fintype.equivFin A x).isLt |
| good_iff w i := by |
| simp only [decide_eq_true_eq] |
| constructor |
| · intro h |
| exact ⟨(Fintype.equivFin A).symm ⟨i,h⟩, congrArg Fin.val ((Fintype.equivFin A).apply_symm_apply _)⟩ |
| · rintro ⟨x,rfl⟩; exact (Fintype.equivFin A x).isLt |
| bound_poly := NatPoly.const _ |
| good_poly := NatPoly.lt (NatPoly.var _) (NatPoly.const _) |
|
|
| def fin (f : Word → ℕ) (hf : NatPoly (fun S : Fin 1 → Word => f (S 0))) : |
| Presented (fun w => Fin (f w)) where |
| code w := NaturalCode.fin (f w) |
| bound := f |
| good w i := decide (i<f w) |
| code_lt _ x := x.isLt |
| good_iff w i := by simp only [decide_eq_true_eq]; exact ⟨fun h => ⟨⟨i,h⟩,rfl⟩, fun ⟨x,h⟩ => h ▸ x.isLt⟩ |
| bound_poly := hf |
| good_poly := NatPoly.lt (NatPoly.var _) (hf.rename (fun _ => 0)) |
|
|
| def subtype (P : Presented A) (p : (w : Word) → A w → Prop) (q : Word → ℕ → Bool) |
| (hq : ∀ w x, q w (P.code w x)=true ↔ p w x) |
| (hp : BoolPoly (fun S : Fin 2 → Word => q (S 0) (S 1).length)) : |
| Presented (fun w => {x : A w // p w x}) where |
| code w := NaturalCode.subtype (P.code w) (p w) |
| bound := P.bound |
| good w i := P.good w i && q w i |
| code_lt w x := P.code_lt w x.val |
| good_iff w i := by |
| simp only [Bool.and_eq_true] |
| constructor |
| · rintro ⟨h,hq'⟩ |
| obtain ⟨x,rfl⟩ := (P.good_iff w i).mp h |
| exact ⟨⟨x,(hq w x).mp hq'⟩,rfl⟩ |
| · rintro ⟨x,rfl⟩ |
| exact ⟨P.good_code w x.val,(hq w x.val).mpr x.property⟩ |
| bound_poly := P.bound_poly |
| good_poly := BoolPoly.and P.good_poly hp |
|
|
| def sigma (P : Presented A) (B : (w : Word) → A w → Type) |
| (c : ∀ w x, B w x ↪ ℕ) (b : Word → ℕ) (q : Word → ℕ → ℕ → Bool) |
| (hc : ∀ w x y, c w x y < b w) |
| (hq : ∀ w x i, q w (P.code w x) i=true ↔ ∃ y, c w x y=i) |
| (hb : NatPoly (fun S : Fin 1 → Word => b (S 0))) |
| (hp : BoolPoly (fun S : Fin 3 → Word => q (S 0) (S 1).length (S 2).length)) : |
| Presented (fun w => Σ x, B w x) where |
| code w := NaturalCode.sigma (P.code w) (c w) |
| bound w := Nat.pair (P.bound w) (b w)+1 |
| good w i := P.good w (Nat.unpair i).1 && q w (Nat.unpair i).1 (Nat.unpair i).2 |
| code_lt w x := by |
| exact (Nat.pair_lt_pair_left _ (P.code_lt w x.1)).trans |
| ((Nat.pair_lt_pair_right _ (hc w x.1 x.2)).trans_le (Nat.le_succ _)) |
| good_iff w i := by |
| simp only [Bool.and_eq_true] |
| constructor |
| · rintro ⟨h,hq'⟩ |
| obtain ⟨x,hx⟩ := (P.good_iff w _).mp h |
| rw [← hx] at hq' |
| obtain ⟨y,hy⟩ := (hq w x _).mp hq' |
| exact ⟨⟨x,y⟩, by change Nat.pair _ _ = i; rw [hx,hy,Nat.pair_unpair]⟩ |
| · rintro ⟨⟨x,y⟩,rfl⟩ |
| change P.good w (Nat.unpair (Nat.pair _ _)).1=true ∧ q w (Nat.unpair (Nat.pair _ _)).1 (Nat.unpair (Nat.pair _ _)).2=true |
| rw [Nat.unpair_pair] |
| exact ⟨P.good_code w x,(hq w x _).mpr ⟨y,rfl⟩⟩ |
| bound_poly := NatPoly.succ (NatPoly.pair P.bound_poly hb) |
| good_poly := by |
| apply BoolPoly.and |
| · apply P.good_poly_of <;> word_poly |
| · have h := hp.subst (g := ![fun S : Fin 2 → Word => S 0, |
| fun S => unary (Nat.unpair (S 1).length).1, fun S => unary (Nat.unpair (S 1).length).2]) |
| (by intro i; fin_cases i <;> word_poly) |
| simpa [unary] using h |
| |
| end Presented |
| end FinitePresentation |
| |
| namespace FinitePresentation.Presented |
| open WordExpressions |
| variable {A B : Word → Type} |
| |
| def retype (P : Presented A) (e : ∀ w, B w ≃ A w) : Presented B where |
| code w := (e w).toEmbedding.trans (P.code w) |
| bound := P.bound |
| good := P.good |
| code_lt w x := P.code_lt w (e w x) |
| good_iff w i := (P.good_iff w i).trans ⟨fun ⟨x,h⟩ => ⟨(e w).symm x, by simpa using h⟩, |
| fun ⟨x,h⟩ => ⟨e w x,h⟩⟩ |
| bound_poly := P.bound_poly |
| good_poly := P.good_poly |
| |
| def prod (P : Presented A) (Q : Presented B) : Presented (fun w => A w × B w) := |
| (P.sigma (fun w _ => B w) (fun w _ => Q.code w) Q.bound (fun w _ => Q.good w) |
| (fun w _ y => Q.code_lt w y) (fun w _ i => Q.good_iff w i) Q.bound_poly |
| (Q.good_poly.rename ![0,2])).retype (fun _ => Equiv.sigmaEquivProd _ _ |>.symm) |
| |
| def sum (P : Presented A) (Q : Presented B) : Presented (fun w => A w ⊕ B w) where |
| code w := NaturalCode.sum (P.code w) (Q.code w) |
| bound w := 2*(P.bound w+Q.bound w)+2 |
| good w i := if i%2=0 then P.good w (i/2) else Q.good w (i/2) |
| code_lt w x := by cases x with |
| | inl a => have := P.code_lt w a; change 2*P.code w a < _; omega |
| | inr b => have := Q.code_lt w b; change 2*Q.code w b+1 < _; omega |
| good_iff w i := by |
| by_cases he : i%2=0 |
| · simp only [he, ↓reduceIte, P.good_iff] |
| constructor |
| · rintro ⟨a,ha⟩ |
| refine ⟨.inl a, ?_⟩ |
| change 2*P.code w a=i |
| omega |
| · rintro ⟨a,ha⟩ |
| cases a with |
| | inl a => exact ⟨a, by change 2*P.code w a=i at ha; omega⟩ |
| | inr b => change 2*Q.code w b+1=i at ha; omega |
| · simp only [he, ↓reduceIte, Q.good_iff] |
| constructor |
| · rintro ⟨b,hb⟩ |
| refine ⟨.inr b, ?_⟩ |
| change 2*Q.code w b+1=i |
| omega |
| · rintro ⟨a,ha⟩ |
| cases a with |
| | inl a => change 2*P.code w a=i at ha; omega |
| | inr b => exact ⟨b, by change 2*Q.code w b+1=i at ha; omega⟩ |
| bound_poly := by word_poly; exact P.bound_poly; exact Q.bound_poly |
| good_poly := by |
| apply BoolPoly.iteProp |
| · word_poly |
| · apply P.good_poly_of <;> word_poly |
| · apply Q.good_poly_of <;> word_poly |
| |
| def option (P : Presented A) : Presented (fun w => Option (A w)) where |
| code w := NaturalCode.option (P.code w) |
| bound w := P.bound w+1 |
| good w i := decide (i=0) || (decide (0 < i) && P.good w (i-1)) |
| code_lt w x := by cases x with |
| | none => change 0 < P.bound w+1; omega |
| | some a => exact Nat.succ_lt_succ (P.code_lt w a) |
| good_iff w i := by |
| simp only [Bool.or_eq_true, Bool.and_eq_true, decide_eq_true_eq] |
| constructor |
| · rintro (rfl | ⟨hi,hg⟩) |
| · exact ⟨none,rfl⟩ |
| · obtain ⟨a,ha⟩ := (P.good_iff w _).mp hg |
| exact ⟨some a, by change P.code w a+1=i; omega⟩ |
| · rintro ⟨x,rfl⟩ |
| cases x with |
| | none => exact Or.inl rfl |
| | some a => exact Or.inr ⟨by change 0 < P.code w a+1; omega, by change P.good w (P.code w a+1-1)=true; simp⟩ |
| bound_poly := NatPoly.succ P.bound_poly |
| good_poly := BoolPoly.or (NatPoly.eqtest (NatPoly.var _) (NatPoly.const _)) |
| (BoolPoly.and (NatPoly.lt (NatPoly.const 0) (NatPoly.var _)) |
| (P.good_poly_of (Poly.var _) (NatPoly.sub (NatPoly.var _) (NatPoly.const 1)))) |
| |
| def bool : Presented (fun _ => Bool) where |
| code _ := NaturalCode.bool |
| bound _ := 2 |
| good _ i := decide (i<2) |
| code_lt _ x := by cases x <;> decide |
| good_iff _ i := by |
| simp only [decide_eq_true_eq] |
| constructor |
| · intro hi |
| interval_cases i |
| · exact ⟨false,rfl⟩ |
| · exact ⟨true,rfl⟩ |
| · rintro ⟨x,rfl⟩; cases x <;> decide |
| bound_poly := NatPoly.const _ |
| good_poly := NatPoly.lt (NatPoly.var _) (NatPoly.const 2) |
| |
| def unit : Presented (fun _ => Unit) where |
| code _ := NaturalCode.unit |
| bound _ := 1 |
| good _ i := decide (i=0) |
| code_lt _ x := by cases x; decide |
| good_iff _ i := by simp only [decide_eq_true_eq]; exact ⟨fun h => ⟨(),h.symm⟩,fun ⟨_,h⟩ => h.symm⟩ |
| bound_poly := NatPoly.const _ |
| good_poly := NatPoly.eqtest (NatPoly.var _) (NatPoly.const 0) |
| |
| end FinitePresentation.Presented |
| |
| namespace FinitePresentation.Presented |
| open WordExpressions NumericFinite |
| variable {A : Word → Type} |
| |
| abbrev card (P : Presented A) (w : Word) := count (P.bound w) (P.good w) |
| abbrev select (P : Presented A) (w : Word) (i : ℕ) := NumericFinite.select (P.bound w) (P.good w) i |
| |
| theorem rank_lt (P : Presented A) (w : Word) (x : A w) : count (P.code w x) (P.good w) < P.card w := |
| count_strict (P.code_lt w x) (P.good_code w x) |
| |
| theorem select_good (P : Presented A) (w : Word) {i : ℕ} (hi : i<P.card w) : |
| P.good w (P.select w i)=true := by |
| rw [select, select_correct _ _ _ hi] |
| exact (mem_elements.mp (List.getElem_mem hi)).2 |
| |
| theorem rank_select (P : Presented A) (w : Word) {i : ℕ} (hi : i<P.card w) : |
| count (P.select w i) (P.good w)=i := by |
| rw [select, select_correct _ _ _ hi] |
| exact NumericFinite.rank _ _ _ hi |
| |
| theorem select_rank (P : Presented A) (w : Word) (x : A w) : |
| P.select w (count (P.code w x) (P.good w))=P.code w x := by |
| have hr := P.rank_select w (P.rank_lt w x) |
| have hg := P.select_good w (P.rank_lt w x) |
| rcases lt_trichotomy (P.select w (count (P.code w x) (P.good w))) (P.code w x) with hl | he | hl |
| · have := count_strict hl hg; omega |
| · exact he |
| · have := count_strict hl (P.good_code w x); omega |
| |
| noncomputable def decode (P : Presented A) (w : Word) (i : Fin (P.card w)) : A w := |
| Classical.choose ((P.good_iff w _).mp (P.select_good w i.isLt)) |
| |
| theorem code_decode (P : Presented A) (w : Word) (i : Fin (P.card w)) : |
| P.code w (P.decode w i)=P.select w i := |
| Classical.choose_spec ((P.good_iff w _).mp (P.select_good w i.isLt)) |
| |
| noncomputable def rankEquiv (P : Presented A) (w : Word) : A w ≃ Fin (P.card w) where |
| toFun x := ⟨count (P.code w x) (P.good w), P.rank_lt w x⟩ |
| invFun := P.decode w |
| left_inv x := by apply (P.code w).injective; rw [P.code_decode, P.select_rank] |
| right_inv i := by apply Fin.ext; exact (congrArg (fun j => count j (P.good w)) (P.code_decode w i)).trans (P.rank_select w i.isLt) |
| |
| @[simp] theorem card_eq (P : Presented A) (w : Word) [Fintype (A w)] : P.card w=Fintype.card (A w) := by |
| simpa only [Fintype.card_fin] using (Fintype.card_congr (P.rankEquiv w)).symm |
| |
| theorem card_poly (P : Presented A) : NatPoly (fun S : Fin 1 → Word => P.card (S 0)) := by |
| apply (NatPoly.filterCount P.bound_poly P.good_poly).congr |
| intro S |
| simp [Fin.snoc, unary, card] |
| |
| theorem card_poly_of (P : Presented A) {n} {w : (Fin n → Word) → Word} (hw : Poly w) : |
| NatPoly (fun S => P.card (w S)) := |
| P.card_poly.subst (g := fun _ => w) (fun _ => hw) |
| |
| theorem select_poly (P : Presented A) : NatPoly (fun S : Fin 2 → Word => P.select (S 0) (S 1).length) := by |
| apply (NatPoly.filterSelect (P.bound_poly.rename (fun _ => 0)) (NatPoly.var 1) |
| (P.good_poly.rename ![0,2])).congr |
| intro S |
| simp [Fin.snoc, unary, select] |
| |
| theorem select_poly_of (P : Presented A) {n} {w : (Fin n → Word) → Word} {i : (Fin n → Word) → ℕ} |
| (hw : Poly w) (hi : NatPoly i) : NatPoly (fun S => P.select (w S) (i S)) := by |
| have h := P.select_poly.subst (g := ![w, fun S => unary (i S)]) (by intro i; fin_cases i; exacts [hw,hi]) |
| simpa [unary] using h |
| |
| end FinitePresentation.Presented |
| |
| namespace FinitePresentation |
| open WordExpressions |
| variable {A : Word → Type} |
| |
| structure PresentedGraph (P : Presented A) (G : ∀ w, SimpleGraph (A w)) where |
| adjacent : Word → ℕ → ℕ → Bool |
| adjacent_iff : ∀ w x y, adjacent w (P.code w x) (P.code w y)=true ↔ (G w).Adj x y |
| adjacent_poly : BoolPoly (fun S : Fin 3 → Word => adjacent (S 0) (S 1).length (S 2).length) |
| |
| namespace PresentedGraph |
| variable {P : Presented A} {G : ∀ w, SimpleGraph (A w)} (Q : PresentedGraph P G) |
| |
| noncomputable def graph (w : Word) : Graph where |
| order := P.card w |
| edge i j := Q.adjacent w (P.select w i) (P.select w j) |
| symmetric i j := by |
| rw [← P.code_decode w i, ← P.code_decode w j] |
| apply Bool.eq_iff_iff.mpr |
| rw [Q.adjacent_iff, Q.adjacent_iff, (G w).adj_comm] |
| loopless i := by |
| rw [← P.code_decode w i] |
| apply Bool.eq_false_iff.mpr |
| intro h |
| exact (G w).loopless.irrefl _ ((Q.adjacent_iff w _ _).mp h) |
| |
| theorem graph_isomorphic (w : Word) [Fintype (A w)] : Isomorphic (Q.graph w) (graphOfSimple (G w)) := by |
| classical |
| refine ⟨(P.rankEquiv w).symm.trans (Fintype.equivFin (A w)), ?_⟩ |
| intro i j |
| change Q.adjacent w (P.select w i) (P.select w j) = _ |
| rw [← P.code_decode w i, ← P.code_decode w j] |
| change _ = (graphOfSimple (G w)).edge (Fintype.equivFin _ (P.decode w i)) (Fintype.equivFin _ (P.decode w j)) |
| rw [graphOfSimple_edge] |
| apply Bool.eq_iff_iff.mpr |
| simp only [Q.adjacent_iff, decide_eq_true_eq] |
| |
| end PresentedGraph |
| end FinitePresentation |
| |
| end WLIdentification |
| |
| end OAI |
| |
