| import OAI.Computability.WitnessedChoice.CountingTransfer |
|
|
| namespace OAI |
|
|
|
|
| namespace WitnessedSeparation.Interpretations |
|
|
| noncomputable section |
|
|
| open Classical Counting HFCoding Hereditary |
|
|
| variable {ι R T L : Type} {A : ι → Type} {d : ∀ i, Set (HF (A i))} |
|
|
| variable (S : ι → Structure R) (C : ∀ i, Counting.Structure L (Domain (d i))) |
|
|
| variable (e : ∀ i, (S i).Carrier → Domain (d i)) (he : ∀ i, Function.Injective (e i)) |
|
|
| variable {m B : ℕ} (I : Interpretation R T) |
|
|
| def EncodedDomain : ∀ i, (Fin 2 → Domain (d i)) → Prop := fun i v => |
| ∃ p : I.Domain (S i), v 0 = e i p.val.1 ∧ v 1 = e i p.val.2 |
|
|
| def EncodedLink : ∀ i, (Fin 4 → Domain (d i)) → Prop := fun i v => |
| ∃ p q : I.Domain (S i), v 0 = e i p.val.1 ∧ v 1 = e i p.val.2 ∧ |
| v 2 = e i q.val.1 ∧ v 3 = e i q.val.2 ∧ Reachability.Link (I.link (S i)) p q |
|
|
| def EncodedClass : ∀ i, (Fin 4 → Domain (d i)) → Prop := fun i v => |
| ∃ p q : I.Domain (S i), v 0 = e i p.val.1 ∧ v 1 = e i p.val.2 ∧ |
| v 2 = e i q.val.1 ∧ v 3 = e i q.val.2 ∧ Quotient.mk (I.classSetoid (S i)) p = Quotient.mk _ q |
|
|
| variable (U : ∀ i, Domain (d i) → Prop) (hU : ∀ i x, U i x ↔ ∃ a, e i a = x) |
|
|
| variable (hdu : UniformDefinable C m 1 (fun i v => U i (v 0))) |
|
|
| variable (δ : ∀ i, (Fin 2 → Domain (d i)) → Prop) (hdδ : UniformDefinable C m 2 δ) |
|
|
| variable (hδ : ∀ i v, δ i (e i ∘ v) ↔ I.domain.eval (S i) v) |
|
|
| include hU hdu hdδ hδ |
|
|
| theorem uniform_domain : UniformDefinable C m 2 (EncodedDomain S e I) := by |
| have h₁ : UniformDefinable C m 2 (fun i v => U i (v 0)) := by simpa using hdu.reindex (![0] : Fin 1 → Fin 2) |
| have h₂ : UniformDefinable C m 2 (fun i v => U i (v 1)) := by simpa using hdu.reindex (![1] : Fin 1 → Fin 2) |
| apply (h₁.and (h₂.and hdδ)).congr |
| intro i v |
| constructor |
| · rintro ⟨h₁,h₂,hv⟩ |
| obtain ⟨a,ha⟩ := (hU i (v 0)).mp h₁ |
| obtain ⟨b,hb⟩ := (hU i (v 1)).mp h₂ |
| have hvv : e i ∘ ![a,b] = v := by ext k; fin_cases k <;> simp [ha,hb] |
| exact ⟨⟨(a,b),(hδ i _).mp (by rw [hvv]; exact hv)⟩,ha.symm,hb.symm⟩ |
| · rintro ⟨p,h₁,h₂⟩ |
| have hvv : e i ∘ ![p.val.1,p.val.2] = v := by ext k; fin_cases k <;> simp [h₁,h₂] |
| refine ⟨(hU i _).mpr ⟨p.val.1,h₁.symm⟩,(hU i _).mpr ⟨p.val.2,h₂.symm⟩,?_⟩ |
| rw [← hvv] |
| exact (hδ i _).mpr p.property |
|
|
| omit hU hdu hdδ hδ |
|
|
| variable (hdom : UniformDefinable C m 2 (EncodedDomain S e I)) |
|
|
| variable (η : ∀ i, (Fin 4 → Domain (d i)) → Prop) (hdη : UniformDefinable C m 4 η) |
|
|
| variable (hη : ∀ i v, η i (e i ∘ v) ↔ I.identify.eval (S i) v) |
|
|
| include he hdom hdη hη |
|
|
| theorem uniform_link : UniformDefinable C m 4 (EncodedLink S e I) := by |
| have h₁ := hdom.reindex (![0,1] : Fin 2 → Fin 4) |
| have h₂ := hdom.reindex (![2,3] : Fin 2 → Fin 4) |
| have heq : UniformDefinable C m 4 (fun _ v => v 0 = v 2 ∧ v 1 = v 3) := |
| (UniformDefinable.equal 0 2).and (UniformDefinable.equal 1 3) |
| have ht := hdη.reindex (![2,3,0,1] : Fin 4 → Fin 4) |
| apply (h₁.and (h₂.and (heq.or (hdη.or ht)))).congr |
| intro i v |
| constructor |
| · rintro ⟨⟨p,hp₁,hp₂⟩,⟨q,hq₁,hq₂⟩,hr⟩ |
| refine ⟨p,q,hp₁,hp₂,hq₁,hq₂,?_⟩ |
| rcases hr with ⟨he₁,he₂⟩ | hr | hr |
| · exact Or.inl (Subtype.ext (Prod.ext (he i (hp₁.symm.trans (he₁.trans hq₁))) |
| (he i (hp₂.symm.trans (he₂.trans hq₂))))) |
| · have hvv : e i ∘ ![p.val.1,p.val.2,q.val.1,q.val.2] = v := by |
| funext k; fin_cases k |
| · exact hp₁.symm |
| · exact hp₂.symm |
| · exact hq₁.symm |
| · exact hq₂.symm |
| exact Or.inr (Or.inl ((hη i _).mp (by rw [hvv]; exact hr))) |
| · have hvv : e i ∘ ![q.val.1,q.val.2,p.val.1,p.val.2] = v ∘ ![2,3,0,1] := by |
| funext k; fin_cases k |
| · exact hq₁.symm |
| · exact hq₂.symm |
| · exact hp₁.symm |
| · exact hp₂.symm |
| exact Or.inr (Or.inr ((hη i _).mp (by rw [hvv]; exact hr))) |
| · rintro ⟨p,q,hp₁,hp₂,hq₁,hq₂,hr⟩ |
| refine ⟨⟨p,hp₁,hp₂⟩,⟨q,hq₁,hq₂⟩,?_⟩ |
| rcases hr with rfl | hr | hr |
| · exact Or.inl ⟨hp₁.trans hq₁.symm,hp₂.trans hq₂.symm⟩ |
| · have hvv : e i ∘ ![p.val.1,p.val.2,q.val.1,q.val.2] = v := by |
| funext k; fin_cases k |
| · exact hp₁.symm |
| · exact hp₂.symm |
| · exact hq₁.symm |
| · exact hq₂.symm |
| exact Or.inr (Or.inl (by rw [← hvv]; exact (hη i _).mpr hr)) |
| · have hvv : e i ∘ ![q.val.1,q.val.2,p.val.1,p.val.2] = v ∘ ![2,3,0,1] := by |
| funext k; fin_cases k |
| · exact hq₁.symm |
| · exact hq₂.symm |
| · exact hp₁.symm |
| · exact hp₂.symm |
| exact Or.inr (Or.inr (by rw [← hvv]; exact (hη i _).mpr hr)) |
|
|
| omit hdom hdη hη |
|
|
| variable (hlink : UniformDefinable C m 4 (EncodedLink S e I)) |
|
|
| include hlink |
|
|
| theorem uniform_class (hm : 6 ≤ m) (hB : ∀ i, Nat.card (S i).Carrier ≤ B) : |
| UniformDefinable C m 4 (EncodedClass S e I) := by |
| apply (Counting.uniform_pairReach C (EncodedLink S e I) hlink hm (B^2)).congr |
| intro i v |
| have hinj : Function.Injective (fun p : I.Domain (S i) => (e i p.val.1,e i p.val.2)) := by |
| intro p q hpq |
| exact Subtype.ext (Prod.ext (he i (congrArg Prod.fst hpq)) (he i (congrArg Prod.snd hpq))) |
| have hc : Fintype.card (I.Domain (S i)) ≤ B^2 := by |
| apply le_trans (Fintype.card_subtype_le _) |
| rw [Fintype.card_prod,← Nat.card_eq_fintype_card] |
| simpa only [pow_two] using Nat.mul_self_le_mul_self (hB i) |
| have h := Counting.pairReach_eqv (I.Domain (S i)) (I.link (S i)) |
| (fun p => e i p.val.1) (fun p => e i p.val.2) hinj (EncodedLink S e I i) |
| (fun _ => Iff.rfl) (B^2) hc v |
| have heq : PairReach (EncodedLink S e I) (B^2) i v = |
| PairReach (fun _ : Unit => EncodedLink S e I i) (B^2) () v := by |
| clear h |
| generalize B^2 = t |
| induction t generalizing v with |
| | zero => rfl |
| | succ t ih => simp only [PairReach,ih] |
| rw [heq,h] |
| unfold EncodedClass |
| apply exists_congr |
| intro p |
| apply exists_congr |
| intro q |
| refine and_congr_right (fun _ => and_congr_right (fun _ => and_congr_right (fun _ => |
| and_congr_right (fun _ => ?_)))) |
| change (I.classSetoid (S i)).r p q ↔ _ |
| exact Quotient.eq.symm |
|
|
| end |
|
|
|
|
|
|
|
|
|
|
| noncomputable section |
|
|
| open Classical Counting HFCoding Hereditary |
|
|
| variable {ι R T L : Type} {A : ι → Type} {d : ∀ i, Set (HF (A i))} |
|
|
| variable (S : ι → Structure R) (C : ∀ i, Counting.Structure L (Domain (d i))) |
|
|
| variable (e : ∀ i, (S i).Carrier → Domain (d i)) (he : ∀ i, Function.Injective (e i)) |
|
|
| variable {m : ℕ} (I : Interpretation R T) |
|
|
| def EncodedPayload : ∀ i, (Fin 3 → Domain (d i)) → Prop := fun i v => |
| ∃ p : I.Domain (S i), v 1 = e i p.val.1 ∧ v 2 = e i p.val.2 ∧ |
| (v 0).val = payload I (S i) (Subtype.val ∘ e i) (Quotient.mk _ p) |
|
|
| def EncodedRep (j : ℕ) : ∀ i, (Fin 3 → Domain (d i)) → Prop := fun i v => |
| ∃ p : I.Domain (S i), v 1 = e i p.val.1 ∧ v 2 = e i p.val.2 ∧ |
| (v 0).val = vertexCode I (S i) (Subtype.val ∘ e i) j (Quotient.mk _ p) |
|
|
| variable (hd : ∀ i, ∀ x ∈ d i, ∀ y, y ∈ x → y ∈ d i) |
|
|
| variable (hmem : UniformDefinable C m 2 (fun _ v => (v 0).val ∈ (v 1).val)) |
|
|
| variable (hset : UniformDefinable C m 1 (fun _ v => isSet (v 0).val = true)) |
|
|
| variable (hm : 6 ≤ m) |
|
|
| variable (hdom : UniformDefinable C m 2 (EncodedDomain S e I)) |
|
|
| variable (hclass : UniformDefinable C m 4 (EncodedClass S e I)) |
|
|
| variable (hpairs : ∀ i (p : I.Domain (S i)), pair (e i p.val.1).val (e i p.val.2).val ∈ d i) |
|
|
| include he hd hmem hset hm hdom hclass hpairs |
|
|
| theorem uniform_payload : UniformDefinable C m 3 (EncodedPayload S e I) := by |
| have hc := hclass.reindex (![4,5,1,0] : Fin 4 → Fin 6) |
| have hp := (HFCoding.uniform_pair C hmem hset hm hd).reindex (![2,1,0] : Fin 3 → Fin 6) |
| have hr := ((hc.and hp).ex (by omega)).ex (by omega) |
| have hmem' := hmem.reindex (![0,1] : Fin 2 → Fin 4) |
| have hall := (hmem'.iff hr).all (by omega) |
| have hs := hset.reindex (![0] : Fin 1 → Fin 3) |
| have hdo := hdom.reindex (![1,2] : Fin 2 → Fin 3) |
| apply (hs.and (hdo.and hall)).congr |
| intro i v |
| change (isSet (v 0).val = true ∧ EncodedDomain S e I i ![v 1,v 2] ∧ |
| ∀ z : Domain (d i), z.val ∈ (v 0).val ↔ ∃ b₁ b₂ : Domain (d i), |
| EncodedClass S e I i ![v 1,v 2,b₁,b₂] ∧ z.val = pair b₁.val b₂.val) ↔ _ |
| constructor |
| · rintro ⟨hs,⟨p,hp₁,hp₂⟩,h⟩ |
| refine ⟨p,hp₁,hp₂,?_⟩ |
| apply ext_sets hs (isSet_ofFinset _) |
| intro z |
| change z ∈ (v 0).val ↔ z ∈ payload I (S i) (Subtype.val ∘ e i) (Quotient.mk _ p) |
| rw [mem_payload] |
| constructor |
| · intro hz |
| obtain ⟨b₁,b₂,⟨p',q,hp'₁,hp'₂,hq₁,hq₂,hpq⟩,hzq⟩ := |
| (h ⟨z,hd i _ (v 0).property _ hz⟩).mp hz |
| have hpp : p = p' := Subtype.ext (Prod.ext (he i (hp₁.symm.trans hp'₁)) (he i (hp₂.symm.trans hp'₂))) |
| subst p' |
| change b₁ = e i q.val.1 at hq₁ |
| change b₂ = e i q.val.2 at hq₂ |
| exact ⟨q,hpq.symm,by simpa only [hq₁,hq₂,Function.comp_apply] using hzq⟩ |
| · rintro ⟨q,hqp,rfl⟩ |
| have hz := hpairs i q |
| exact (h ⟨_,hz⟩).mpr ⟨e i q.val.1,e i q.val.2, |
| ⟨p,q,hp₁,hp₂,rfl,rfl,hqp.symm⟩,rfl⟩ |
| · rintro ⟨p,hp₁,hp₂,hv⟩ |
| refine ⟨by rw [hv]; exact isSet_ofFinset _,⟨p,hp₁,hp₂⟩,?_⟩ |
| intro z |
| rw [hv,mem_payload] |
| constructor |
| · rintro ⟨q,hqp,hzq⟩ |
| exact ⟨e i q.val.1,e i q.val.2,⟨p,q,hp₁,hp₂,rfl,rfl,hqp.symm⟩,hzq⟩ |
| · rintro ⟨b₁,b₂,⟨p',q,hp'₁,hp'₂,hq₁,hq₂,hpq⟩,hzq⟩ |
| have hpp : p = p' := Subtype.ext (Prod.ext (he i (hp₁.symm.trans hp'₁)) (he i (hp₂.symm.trans hp'₂))) |
| subst p' |
| change b₁ = e i q.val.1 at hq₁ |
| change b₂ = e i q.val.2 at hq₂ |
| exact ⟨q,hpq.symm,by simpa only [hq₁,hq₂,Function.comp_apply] using hzq⟩ |
|
|
| end |
|
|
|
|
|
|
|
|
|
|
| noncomputable section |
|
|
| open Classical Counting HFCoding Hereditary |
|
|
| variable {ι R T L : Type} {A : ι → Type} {d : ∀ i, Set (HF (A i))} |
|
|
| variable (S : ι → Structure R) (C : ∀ i, Counting.Structure L (Domain (d i))) |
|
|
| variable (e : ∀ i, (S i).Carrier → Domain (d i)) |
|
|
| variable {m : ℕ} (I : Interpretation R T) |
|
|
| variable (hd : ∀ i, ∀ x ∈ d i, ∀ y, y ∈ x → y ∈ d i) |
|
|
| variable (hmem : UniformDefinable C m 2 (fun _ v => (v 0).val ∈ (v 1).val)) |
|
|
| variable (hset : UniformDefinable C m 1 (fun _ v => isSet (v 0).val = true)) |
|
|
| variable (hm : 6 ≤ m) (hpure : ∀ i k, ordinal (A := A i) k ∈ d i) |
|
|
| variable (hpayload : UniformDefinable C m 3 (EncodedPayload S e I)) |
|
|
| include hd hmem hset hm hpure hpayload |
|
|
| theorem uniform_rep (j : ℕ) : UniformDefinable C m 3 (EncodedRep S e I j) := by |
| have ho := (HFCoding.uniform_ordinal C hmem hset hm hd hpure j).reindex (![1] : Fin 1 → Fin 5) |
| have hs := hpayload.reindex (![0,3,4] : Fin 3 → Fin 5) |
| have hp := (HFCoding.uniform_pair C hmem hset hm hd).reindex (![2,1,0] : Fin 3 → Fin 5) |
| apply (((ho.and (hs.and hp)).ex (by omega)).ex (by omega)).congr |
| intro i v |
| change (∃ o S' : Domain (d i), o.val = ordinal j ∧ EncodedPayload S e I i ![S',v 1,v 2] ∧ |
| (v 0).val = pair o.val S'.val) ↔ _ |
| constructor |
| · rintro ⟨o,S',ho,⟨p,hp₁,hp₂,hS⟩,hx⟩ |
| change S'.val = payload I (S i) (Subtype.val ∘ e i) (Quotient.mk _ p) at hS |
| exact ⟨p,hp₁,hp₂,by simpa only [vertexCode,ho,hS] using hx⟩ |
| · rintro ⟨p,hp₁,hp₂,hx⟩ |
| let pl := payload I (S i) (Subtype.val ∘ e i) (Quotient.mk _ p) |
| have hp : pl ∈ d i := by |
| have hdbl : double (ordinal j) pl ∈ d i := hd i _ (v 0).property _ (by rw [hx]; simp [vertexCode,pair,pl]) |
| exact hd i _ hdbl _ (by simp) |
| exact ⟨⟨ordinal j,hpure i j⟩,⟨pl,hp⟩,rfl,⟨p,hp₁,hp₂,rfl⟩,hx⟩ |
| |
| omit hd hmem hset hpure hpayload |
| |
| variable (j : ℕ) (hrep : UniformDefinable C m 3 (EncodedRep S e I j)) |
| |
| include hrep |
| |
| def EncodedUniverse : ∀ i, (Fin 1 → Domain (d i)) → Prop := fun i v => |
| ∃ x : I.Vertex (S i), (v 0).val = vertexCode I (S i) (Subtype.val ∘ e i) j x |
| |
| theorem uniform_universe : UniformDefinable C m 1 (EncodedUniverse S e I j) := by |
| have hr := hrep.reindex (![2,1,0] : Fin 3 → Fin 3) |
| apply ((hr.ex (by omega)).ex (by omega)).congr |
| intro i v |
| change (∃ a b, EncodedRep S e I j i ![v 0,a,b]) ↔ _ |
| constructor |
| · rintro ⟨a,b,p,_,_,hx⟩ |
| exact ⟨Quotient.mk _ p,hx⟩ |
| · rintro ⟨x,hx⟩ |
| obtain ⟨p,rfl⟩ := Quotient.exists_rep x |
| exact ⟨e i p.val.1,e i p.val.2,p,rfl,rfl,hx⟩ |
| |
| def EncodedStateRelation (r : T) : ∀ i, (Fin 2 → Domain (d i)) → Prop := fun i v => |
| ∃ x y : I.Vertex (S i), (v 0).val = vertexCode I (S i) (Subtype.val ∘ e i) j x ∧ |
| (v 1).val = vertexCode I (S i) (Subtype.val ∘ e i) j y ∧ (I.apply (S i)).rel r x y = true |
| |
| variable (ρ : ∀ i, (Fin 4 → Domain (d i)) → Prop) |
| |
| variable (hdρ : UniformDefinable C m 4 ρ) |
| |
| include hdρ |
| |
| theorem uniform_stateRelation (r : T) |
| (hρ : ∀ i v, ρ i (e i ∘ v) ↔ (I.relation r).eval (S i) v) : |
| UniformDefinable C m 2 (EncodedStateRelation S e I j r) := by |
| have hx := hrep.reindex (![4,3,2] : Fin 3 → Fin 6) |
| have hy := hrep.reindex (![5,1,0] : Fin 3 → Fin 6) |
| have hr := hdρ.reindex (![3,2,1,0] : Fin 4 → Fin 6) |
| apply (((((hx.and (hy.and hr)).ex (by omega)).ex (by omega)).ex (by omega)).ex (by omega)).congr |
| intro i v |
| have hvec (a₁ a₂ b₁ b₂ : Domain (d i)) : |
| Fin.cons b₂ (Fin.cons b₁ (Fin.cons a₂ (Fin.cons a₁ v))) ∘ ![3,2,1,0] = ![a₁,a₂,b₁,b₂] := by |
| funext k; fin_cases k <;> rfl |
| simp only [hvec] |
| change (∃ a₁ a₂ b₁ b₂, EncodedRep S e I j i ![v 0,a₁,a₂] ∧ |
| EncodedRep S e I j i ![v 1,b₁,b₂] ∧ ρ i ![a₁,a₂,b₁,b₂]) ↔ _ |
| constructor |
| · rintro ⟨a₁,a₂,b₁,b₂,⟨p,hp₁,hp₂,hx⟩,⟨q,hq₁,hq₂,hy⟩,hr⟩ |
| refine ⟨Quotient.mk _ p,Quotient.mk _ q,hx,hy,?_⟩ |
| simp only [Interpretation.apply,decide_eq_true_eq] |
| refine ⟨p,q,rfl,rfl,?_⟩ |
| have hvv : e i ∘ ![p.val.1,p.val.2,q.val.1,q.val.2] = ![a₁,a₂,b₁,b₂] := by |
| funext k; fin_cases k |
| · exact hp₁.symm |
| · exact hp₂.symm |
| · exact hq₁.symm |
| · exact hq₂.symm |
| exact (hρ i _).mp (by rw [hvv]; exact hr) |
| · rintro ⟨x,y,hx,hy,hxy⟩ |
| simp only [Interpretation.apply,decide_eq_true_eq] at hxy |
| obtain ⟨p,q,hp,hq,hr⟩ := hxy |
| refine ⟨e i p.val.1,e i p.val.2,e i q.val.1,e i q.val.2, |
| ⟨p,rfl,rfl,by change (v 0).val = _; rw [hp]; exact hx⟩, |
| ⟨q,rfl,rfl,by change (v 1).val = _; rw [hq]; exact hy⟩,?_⟩ |
| have hvv : e i ∘ ![p.val.1,p.val.2,q.val.1,q.val.2] = |
| ![e i p.val.1,e i p.val.2,e i q.val.1,e i q.val.2] := by funext k; fin_cases k <;> rfl |
| rw [← hvv] |
| exact (hρ i _).mpr hr |
| |
| end |
| |
| |
| |
| |
| |
| noncomputable section |
| |
| open Classical Counting HFCoding Hereditary |
| |
| variable {ι R T L : Type} {D : ι → Type} |
| |
| variable (S : ι → Structure R) (C : ∀ i, Counting.Structure L (D i)) |
| |
| variable (e : ∀ i, (S i).Carrier → D i) {m B : ℕ} |
| |
| structure StateDefinable (m : ℕ) : Prop where |
| domainDef : UniformDefinable C m 1 (fun i v => ∃ a, e i a = v 0) |
| relations : ∀ r, UniformDefinable C m 2 (fun i v => ∃ a b, |
| e i a = v 0 ∧ e i b = v 1 ∧ (S i).rel r a b = true) |
| |
| theorem StateDefinable.translate (h : StateDefinable S C e m) (he : ∀ i, Function.Injective (e i)) |
| (hB : ∀ i, Nat.card (S i).Carrier ≤ B) {k : ℕ} (φ : Formula R k) (hw : φ.scopedWidth < m) : |
| ∃ Q : ∀ i, (Fin k → D i) → Prop, UniformDefinable C m k Q ∧ |
| ∀ i v, Q i (e i ∘ v) ↔ φ.eval (S i) v := by |
| apply uniform_translate S C e he (fun i x => ∃ a, e i a = x) (fun _ _ => Iff.rfl) |
| (fun r i x y => ∃ a b, e i a = x ∧ e i b = y ∧ (S i).rel r a b = true) |
| _ h.domainDef h.relations hB φ hw |
| intro r i a b |
| constructor |
| · rintro ⟨a',b',ha,hb,hr⟩ |
| simpa only [he i ha,he i hb] using hr |
| · exact fun hr => ⟨a,b,rfl,rfl,hr⟩ |
| |
| variable {A : ι → Type} {d : ∀ i, Set (HF (A i))} |
| |
| variable (H : ∀ i, Counting.Structure L (Domain (d i))) |
| |
| variable (f : ∀ i, (S i).Carrier → Domain (d i)) (hf : ∀ i, Function.Injective (f i)) |
| |
| variable (I : Interpretation R T) (j : ℕ) |
| |
| variable (hc : ∀ i x, vertexCode I (S i) (Subtype.val ∘ f i) j x ∈ d i) |
| |
| def nextCode (i : ι) (x : (I.apply (S i)).Carrier) : Domain (d i) := |
| ⟨vertexCode I (S i) (Subtype.val ∘ f i) j x,hc i x⟩ |
| |
| include hf in |
| theorem nextCode_injective (i : ι) : Function.Injective (nextCode S f I j hc i) := by |
| intro x y hxy |
| exact vertexCode_injective I (S i) (Subtype.val ∘ f i) (Subtype.val_injective.comp (hf i)) j |
| (congrArg Subtype.val hxy) |
| |
| include hf |
| |
| theorem StateDefinable.apply (h : StateDefinable S H f m) |
| (hd : ∀ i, ∀ x ∈ d i, ∀ y, y ∈ x → y ∈ d i) |
| (hmem : UniformDefinable H m 2 (fun _ v => (v 0).val ∈ (v 1).val)) |
| (hset : UniformDefinable H m 1 (fun _ v => isSet (v 0).val = true)) |
| (hm : 6 ≤ m) (hpure : ∀ i k, ordinal (A := A i) k ∈ d i) |
| (hpairs : ∀ i (p : I.Domain (S i)), pair (f i p.val.1).val (f i p.val.2).val ∈ d i) |
| (hB : ∀ i, Nat.card (S i).Carrier ≤ B) |
| (hwδ : I.domain.scopedWidth < m) (hwη : I.identify.scopedWidth < m) |
| (hwρ : ∀ r, (I.relation r).scopedWidth < m) : |
| StateDefinable (fun i => I.apply (S i)) H (nextCode S f I j hc) m := by |
| obtain ⟨δ,hdδ,hδ⟩ := h.translate S H f hf hB I.domain hwδ |
| obtain ⟨η,hdη,hη⟩ := h.translate S H f hf hB I.identify hwη |
| have hdom := uniform_domain S H f I (fun i x => ∃ a, f i a = x) |
| (fun _ _ => Iff.rfl) h.domainDef δ hdδ hδ |
| have hlink := uniform_link S H f hf I hdom η hdη hη |
| have hclass := uniform_class S H f hf I hlink hm hB |
| have hpay := uniform_payload S H f hf I hd hmem hset hm hdom hclass hpairs |
| have hrep := uniform_rep S H f I hd hmem hset hm hpure hpay j |
| constructor |
| · apply (uniform_universe S H f I hm j hrep).congr |
| intro i v |
| exact exists_congr (fun x => ⟨fun h => Subtype.ext h.symm,fun h => (congrArg Subtype.val h).symm⟩) |
| · intro r |
| obtain ⟨ρ,hdρ,hρ⟩ := h.translate S H f hf hB (I.relation r) (hwρ r) |
| apply (uniform_stateRelation S H f I hm j hrep ρ hdρ r hρ).congr |
| intro i v |
| apply exists_congr |
| intro x |
| apply exists_congr |
| intro y |
| exact and_congr (⟨fun h => Subtype.ext h.symm,fun h => (congrArg Subtype.val h).symm⟩) |
| (and_congr (⟨fun h => Subtype.ext h.symm,fun h => (congrArg Subtype.val h).symm⟩) Iff.rfl) |
| |
| end |
| |
| end WitnessedSeparation.Interpretations |
| |
| |
| |
| namespace WitnessedSeparation.Interpretations.Program |
| |
| noncomputable section |
| |
| open Classical Counting HFCoding Hereditary Finset |
| |
| variable {ι R L : Type} (P : Program R) |
| |
| theorem exists_width : ∃ m : ℕ, 6 ≤ m ∧ |
| P.init.domain.scopedWidth < m ∧ P.init.identify.scopedWidth < m ∧ |
| (∀ r, (P.init.relation r).scopedWidth < m) ∧ |
| P.step.domain.scopedWidth < m ∧ P.step.identify.scopedWidth < m ∧ |
| (∀ r, (P.step.relation r).scopedWidth < m) ∧ |
| P.halt.scopedWidth < m ∧ P.output.scopedWidth < m := by |
| let := P.stateFinite |
| let b : ℕ := univ.sup (fun r => max (P.init.relation r).scopedWidth (P.step.relation r).scopedWidth) |
| let m := 7 + P.init.domain.scopedWidth + P.init.identify.scopedWidth + b + |
| P.step.domain.scopedWidth + P.step.identify.scopedWidth + P.halt.scopedWidth + P.output.scopedWidth |
| have hb (r) : max (P.init.relation r).scopedWidth (P.step.relation r).scopedWidth ≤ b := |
| le_sup (f := fun r => max (P.init.relation r).scopedWidth (P.step.relation r).scopedWidth) (mem_univ r) |
| refine ⟨m,?_,?_,?_,?_,?_,?_,?_,?_,?_⟩ |
| all_goals first | (intro r; have h := hb r; dsimp [m]; omega) | (dsimp [m]; omega) |
| |
| variable (S : ι → Structure R) {d : ∀ i, Set (HF (S i).Carrier)} |
| |
| variable (C : ∀ i, Counting.Structure L (Domain (d i))) |
| |
| variable {B K m : ℕ} |
| |
| theorem family_mono_le (A : Structure R) (B : ℕ) {j k : ℕ} (h : j ≤ k) : |
| P.family A B j ⊆ P.family A B k := by |
| induction h with |
| | refl => exact Subset.rfl |
| | @step k h ih => exact ih.trans (P.family_mono A B k) |
| |
| variable (hfamily : ∀ i x, x ∈ P.family (S i) B K → x ∈ d i) |
| |
| include hfamily in |
| theorem code_mem_domain {j : ℕ} (hj : j < K) (i : ι) (a : (P.state (S i) j).Carrier) : |
| P.code (S i) j a ∈ d i := |
| hfamily i _ (P.family_mono_le (S i) B (by omega) (P.code_mem_family (S i) B j a)) |
| |
| def stateCode {j : ℕ} (hj : j < K) (i : ι) (a : (P.state (S i) j).Carrier) : Domain (d i) := |
| ⟨P.code (S i) j a,P.code_mem_domain S hfamily hj i a⟩ |
| |
| theorem stateCode_injective {j : ℕ} (hj : j < K) (i : ι) : |
| Function.Injective (P.stateCode S hfamily hj i) := by |
| intro a b h |
| exact P.code_injective (S i) j (congrArg Subtype.val h) |
| |
| def inputCode (i : ι) (a : (S i).Carrier) : Domain (d i) := |
| ⟨atom a,hfamily i _ (P.atom_mem_family (S i) B K a)⟩ |
| |
| theorem inputCode_injective (i : ι) : Function.Injective (P.inputCode S hfamily i) := by |
| intro a b h |
| exact atom_injective (congrArg Subtype.val h) |
| |
| variable (hd : ∀ i, ∀ x ∈ d i, ∀ y, y ∈ x → y ∈ d i) |
| |
| variable (hmem : UniformDefinable C m 2 (fun _ v => (v 0).val ∈ (v 1).val)) |
| |
| variable (hset : UniformDefinable C m 1 (fun _ v => isSet (v 0).val = true)) |
| |
| variable (hm : 6 ≤ m) (hpure : ∀ i k, ordinal (A := (S i).Carrier) k ∈ d i) |
| |
| variable (hN : ∀ i, Nat.card (S i).Carrier ≤ B) |
| |
| variable (hsize : ∀ i j, j < K → Nat.card (P.state (S i) j).Carrier ≤ B) |
| |
| variable (wiδ : P.init.domain.scopedWidth < m) (wiη : P.init.identify.scopedWidth < m) |
| |
| variable (wiρ : ∀ r, (P.init.relation r).scopedWidth < m) |
| |
| variable (wsδ : P.step.domain.scopedWidth < m) (wsη : P.step.identify.scopedWidth < m) |
| |
| variable (wsρ : ∀ r, (P.step.relation r).scopedWidth < m) |
| |
| variable (hinput : StateDefinable S C (P.inputCode S hfamily) m) |
| |
| include hd hmem hset hm hpure hN hsize wiδ wiη wiρ wsδ wsη wsρ hinput |
| |
| theorem state_definable {j : ℕ} (hj : j < K) : |
| StateDefinable (fun i => P.state (S i) j) C (P.stateCode S hfamily hj) m := by |
| induction j with |
| | zero => |
| have hpairs (i) (p : P.init.Domain (S i)) : |
| pair (P.inputCode S hfamily i p.val.1).val (P.inputCode S hfamily i p.val.2).val ∈ d i := by |
| apply hfamily i |
| apply P.family_mono_le (S i) B (show 1 ≤ K by omega) |
| apply mem_union_left |
| apply mem_union_right |
| exact mem_biUnion.mpr ⟨p,mem_univ _,by simp [wrappers,inputCode]⟩ |
| have hc (i) (x : P.init.Vertex (S i)) : |
| vertexCode P.init (S i) (Subtype.val ∘ P.inputCode S hfamily i) 1 x ∈ d i := |
| P.code_mem_domain S hfamily hj i x |
| exact hinput.apply S C (P.inputCode S hfamily) (P.inputCode_injective S hfamily) P.init 1 hc |
| hd hmem hset hm hpure hpairs hN wiδ wiη wiρ |
| | succ j ih => |
| have hj' : j < K := by omega |
| have hpairs (i) (p : P.step.Domain (P.state (S i) j)) : |
| pair (P.stateCode S hfamily hj' i p.val.1).val (P.stateCode S hfamily hj' i p.val.2).val ∈ d i := by |
| apply hfamily i |
| apply P.family_mono_le (S i) B (show j+2 ≤ K by omega) |
| apply mem_union_left |
| apply mem_union_right |
| exact mem_biUnion.mpr ⟨p,mem_univ _,by simp [wrappers,stateCode]⟩ |
| have hc (i) (x : P.step.Vertex (P.state (S i) j)) : |
| vertexCode P.step (P.state (S i) j) (Subtype.val ∘ P.stateCode S hfamily hj' i) (j+2) x ∈ d i := |
| P.code_mem_domain S hfamily hj i x |
| exact (ih hj').apply (fun i => P.state (S i) j) C (P.stateCode S hfamily hj') |
| (P.stateCode_injective S hfamily hj') P.step (j+2) hc hd hmem hset hm hpure hpairs |
| (fun i => hsize i j hj') wsδ wsη wsρ |
|
|
| end |
|
|
| end WitnessedSeparation.Interpretations.Program |
|
|
|
|
|
|
| namespace WitnessedSeparation.Interpretations |
|
|
| noncomputable section |
|
|
| open Classical Counting |
|
|
| variable {ι R L : Type} {D : ι → Type} |
|
|
| variable (S : ι → Structure R) (C : ∀ i, Counting.Structure L (D i)) |
|
|
| variable (e : ∀ i, (S i).Carrier → D i) {m B : ℕ} |
|
|
| theorem StateDefinable.sentence (h : StateDefinable S C e m) (he : ∀ i, Function.Injective (e i)) |
| (hB : ∀ i, Nat.card (S i).Carrier ≤ B) (ψ : Formula R 0) (hw : ψ.scopedWidth < m) : |
| ∃ φ : Counting.Formula L (Fin m), φ.free = ∅ ∧ |
| ∀ i v, φ.eval (C i) v ↔ ψ.holds (S i) := by |
| obtain ⟨Q,hQ,hψ⟩ := h.translate S C e he hB ψ hw |
| obtain ⟨φ,hφ,hφQ⟩ := hQ Fin.elim0 |
| refine ⟨φ,?_,?_⟩ |
| · apply Finset.subset_empty.mp |
| simpa only [Finset.univ_eq_empty,Finset.image_empty] using hφ |
| · intro i v |
| have hv : v ∘ (Fin.elim0 : Fin 0 → Fin m) = e i ∘ Fin.elim0 := by funext k; exact k.elim0 |
| exact (hφQ i v).trans (by rw [hv]; exact hψ i Fin.elim0) |
|
|
| namespace Program |
|
|
| variable {R : Type} (P : Program R) |
|
|
| theorem haltsAt_unique (S : Structure R) {j k : ℕ} (hj : P.haltsAt S j) (hk : P.haltsAt S k) : j = k := by |
| rcases lt_trichotomy j k with h|h|h |
| · exact False.elim (hk.2 j h hj.1) |
| · exact h |
| · exact False.elim (hj.2 k h hk.1) |
|
|
| theorem accepts_iff_of_haltsAt (S : Structure R) {j : ℕ} (hj : P.haltsAt S j) : |
| P.accepts S ↔ P.output.holds (P.state S j) := by |
| constructor |
| · rintro ⟨k,hk,hout⟩ |
| rwa [P.haltsAt_unique S hk hj] at hout |
| · exact fun hout => ⟨j,hj,hout⟩ |
|
|
| theorem synchronize (S T : Structure R) {j k : ℕ} |
| (hj : P.haltsAt S j) (hk : P.haltsAt T k) |
| (hhalt : ∀ l ≤ min j k, P.halt.holds (P.state S l) ↔ P.halt.holds (P.state T l)) |
| (hout : ∀ l ≤ min j k, P.output.holds (P.state S l) ↔ P.output.holds (P.state T l)) : |
| j = k ∧ (P.accepts S ↔ P.accepts T) := by |
| have heq : j = k := by |
| rcases le_total j k with h|h |
| · have hh := (hhalt j (by omega)).mp hj.1 |
| have hkj : k ≤ j := by by_contra h'; exact hk.2 j (by omega) hh |
| omega |
| · have hh := (hhalt k (by omega)).mpr hk.1 |
| have hjk : j ≤ k := by by_contra h'; exact hj.2 k (by omega) hh |
| omega |
| refine ⟨heq,?_⟩ |
| rw [P.accepts_iff_of_haltsAt S hj,P.accepts_iff_of_haltsAt T hk,← heq] |
| exact hout j (by omega) |
|
|
| end Program |
|
|
| end |
|
|
| end WitnessedSeparation.Interpretations |
|
|
|
|
|
|
| namespace WitnessedSeparation.Grid |
|
|
| noncomputable section |
|
|
| open Classical Finset Support |
|
|
| variable {n : ℕ} |
|
|
| private theorem four_fibers {α β : Type*} [Fintype α] [DecidableEq β] |
| (f₀ f₁ f₂ f₃ : α → β) (h₀ : Function.Injective f₀) (h₁ : Function.Injective f₁) |
| (h₂ : Function.Injective f₂) (h₃ : Function.Injective f₃) (e : β) |
| (p : α → Prop) [DecidablePred p] (hp : ∀ a, p a → f₀ a = e ∨ f₁ a = e ∨ f₂ a = e ∨ f₃ a = e) : |
| Fintype.card {a |
| have hcard (f : α → β) (hf : Function.Injective f) : |
| (univ.filter (fun a => f a = e)).card ≤ 1 := by |
| apply Finset.card_le_one.mpr |
| intro a ha b hb |
| exact hf ((mem_filter.mp ha).2.trans (mem_filter.mp hb).2.symm) |
| rw [Fintype.card_subtype] |
| have hs : univ.filter p ⊆ |
| ((univ.filter (fun a => f₀ a = e) ∪ univ.filter (fun a => f₁ a = e)) ∪ |
| univ.filter (fun a => f₂ a = e)) ∪ univ.filter (fun a => f₃ a = e) := by |
| intro a ha |
| have h := hp a (mem_filter.mp ha).2 |
| simpa only [mem_union,mem_filter,mem_univ,true_and,or_assoc] using h |
| exact (card_le_card hs).trans (le_trans (card_union_le _ _) (by |
| have h01 := card_union_le (univ.filter (fun a => f₀ a = e)) (univ.filter (fun a => f₁ a = e)) |
| have h012 := card_union_le |
| (univ.filter (fun a => f₀ a = e) ∪ univ.filter (fun a => f₁ a = e)) |
| (univ.filter (fun a => f₂ a = e)) |
| have := hcard f₀ h₀; have := hcard f₁ h₁; have := hcard f₂ h₂; have := hcard f₃ h₃ |
| omega)) |
|
|
| theorem edgeFaces_card_le (e : Edge n) : Fintype.card (EdgeFaces e) ≤ 12 := by |
| have hxy : Fintype.card {f : FaceXY n |
| refine four_fibers (α := FaceXY n) (β := Edge n) (fun ⟨i,j,k⟩ => ex i j.castSucc k) |
| (fun ⟨i,j,k⟩ => ey i.succ j k) (fun ⟨i,j,k⟩ => ex i j.succ k) |
| (fun ⟨i,j,k⟩ => ey i.castSucc j k) ?_ ?_ ?_ ?_ e _ ?_ |
| · rintro ⟨i,j,k⟩ ⟨i',j',k'⟩ h; simpa [ex] using h |
| · rintro ⟨i,j,k⟩ ⟨i',j',k'⟩ h; simpa [ey] using h |
| · rintro ⟨i,j,k⟩ ⟨i',j',k'⟩ h; simpa [ex] using h |
| · rintro ⟨i,j,k⟩ ⟨i',j',k'⟩ h; simpa [ey] using h |
| · rintro ⟨i,j,k⟩ h |
| by_contra hn |
| push Not at hn |
| apply h |
| simp [cycle,Pi.single_eq_of_ne,Ne.symm hn.1,Ne.symm hn.2.1, |
| Ne.symm hn.2.2.1,Ne.symm hn.2.2.2] |
| have hxz : Fintype.card {f : FaceXZ n |
| refine four_fibers (α := FaceXZ n) (β := Edge n) (fun ⟨i,j,k⟩ => ex i j k.castSucc) |
| (fun ⟨i,j,k⟩ => ez i.succ j k) (fun ⟨i,j,k⟩ => ex i j k.succ) |
| (fun ⟨i,j,k⟩ => ez i.castSucc j k) ?_ ?_ ?_ ?_ e _ ?_ |
| · rintro ⟨i,j,k⟩ ⟨i',j',k'⟩ h; simpa [ex] using h |
| · rintro ⟨i,j,k⟩ ⟨i',j',k'⟩ h; simpa [ez] using h |
| · rintro ⟨i,j,k⟩ ⟨i',j',k'⟩ h; simpa [ex] using h |
| · rintro ⟨i,j,k⟩ ⟨i',j',k'⟩ h; simpa [ez] using h |
| · rintro ⟨i,j,k⟩ h |
| by_contra hn |
| push Not at hn |
| apply h |
| simp [cycle,Pi.single_eq_of_ne,Ne.symm hn.1,Ne.symm hn.2.1, |
| Ne.symm hn.2.2.1,Ne.symm hn.2.2.2] |
| have hyz : Fintype.card {f : FaceYZ n |
| refine four_fibers (α := FaceYZ n) (β := Edge n) (fun ⟨i,j,k⟩ => ey i j k.castSucc) |
| (fun ⟨i,j,k⟩ => ez i j.succ k) (fun ⟨i,j,k⟩ => ey i j k.succ) |
| (fun ⟨i,j,k⟩ => ez i j.castSucc k) ?_ ?_ ?_ ?_ e _ ?_ |
| · rintro ⟨i,j,k⟩ ⟨i',j',k'⟩ h; simpa [ey] using h |
| · rintro ⟨i,j,k⟩ ⟨i',j',k'⟩ h; simpa [ez] using h |
| · rintro ⟨i,j,k⟩ ⟨i',j',k'⟩ h; simpa [ey] using h |
| · rintro ⟨i,j,k⟩ ⟨i',j',k'⟩ h; simpa [ez] using h |
| · rintro ⟨i,j,k⟩ h |
| by_contra hn |
| push Not at hn |
| apply h |
| simp [cycle,Pi.single_eq_of_ne,Ne.symm hn.1,Ne.symm hn.2.1, |
| Ne.symm hn.2.2.1,Ne.symm hn.2.2.2] |
| unfold EdgeFaces Face |
| rw [Fintype.card_congr Equiv.subtypeSum,Fintype.card_sum, |
| Fintype.card_congr Equiv.subtypeSum,Fintype.card_sum] |
| omega |
|
|
| def localSizeBound : ℕ := 3^25 |
|
|
| theorem localGroup_card_le (e : Edge n) : Fintype.card (LocalGroup e) ≤ localSizeBound := by |
| rw [Fintype.card_congr (Support.H.productEquiv (localCycle e)),Fintype.card_prod, |
| Fintype.card_fun,Fintype.card_prod] |
| have hf := edgeFaces_card_le e |
| simp only [Scalar,ZMod.card] at * |
| change (3*3)^Fintype.card (EdgeFaces e)*3 ≤ 3^25 |
| calc |
| (3*3)^Fintype.card (EdgeFaces e)*3 ≤ (3*3)^12*3 := |
| Nat.mul_le_mul_right 3 (Nat.pow_le_pow_right (by norm_num) hf) |
| _ = 3^25 := by norm_num |
|
|
| theorem configuration_card_le (b : Vertex n → Scalar) (v : Vertex n) : |
| Fintype.card (Configuration b v) ≤ localSizeBound^6 := by |
| have hi : Function.Injective (fun s : Configuration b v => s.state) := |
| fun s t h => Configuration.ext (congrFun h) |
| have hdegree : Fintype.card (IncidentEdges v) ≤ 6 := degree_le_six v |
| calc |
| Fintype.card (Configuration b v) ≤ Fintype.card (LocalStates v) := Fintype.card_le_of_injective _ hi |
| _ = ∏ e : IncidentEdges v, Fintype.card (LocalGroup e.val) := Fintype.card_pi |
| _ ≤ ∏ _e : IncidentEdges v, localSizeBound := Finset.prod_le_prod (fun e _ => localGroup_card_le e.val) |
| _ = localSizeBound^Fintype.card (IncidentEdges v) := by simp |
| _ ≤ localSizeBound^6 := Nat.pow_le_pow_right (by norm_num [localSizeBound]) hdegree |
|
|
| def atomSizeConstant : ℕ := 3*localSizeBound+localSizeBound^6 |
|
|
| theorem atom_card_bounds (hn : 1 ≤ n) (b : Vertex n → Scalar) : |
| (n+1)^3 ≤ Fintype.card (Atom b) ∧ |
| Fintype.card (Atom b) ≤ atomSizeConstant*(n+1)^3 := by |
| have hv : Fintype.card (Vertex n) = (n+1)^3 := by simp [Vertex]; ring |
| have he : Fintype.card (Edge n) ≤ 3*(n+1)^3 := by |
| simp only [Edge,EdgeX,EdgeY,EdgeZ,Fintype.card_sum,Fintype.card_prod,Fintype.card_fin] |
| nlinarith |
| constructor |
| · rw [← hv] |
| apply Fintype.card_le_of_injective (fun v : Vertex n => (.inr ⟨v,someConfiguration hn b v⟩ : Atom b)) |
| intro v w h |
| exact congrArg Sigma.fst (Sum.inr.inj h) |
| · change Fintype.card ((Σ e : Edge n, LocalGroup e) ⊕ (Σ v : Vertex n, Configuration b v)) ≤ _ |
| rw [← Nat.card_eq_fintype_card, Nat.card_sum, Nat.card_sigma, Nat.card_sigma] |
| simp only [Nat.card_eq_fintype_card] |
| calc |
| (∑ e : Edge n, Fintype.card (LocalGroup e))+ |
| ∑ v : Vertex n, Fintype.card (Configuration b v) ≤ |
| (∑ _e : Edge n, localSizeBound)+∑ _v : Vertex n, localSizeBound^6 := |
| add_le_add (sum_le_sum (fun e _ => localGroup_card_le e)) |
| (sum_le_sum (fun v _ => configuration_card_le b v)) |
| _ = Fintype.card (Edge n)*localSizeBound+Fintype.card (Vertex n)*localSizeBound^6 := by simp |
| _ ≤ (3*(n+1)^3)*localSizeBound+(n+1)^3*localSizeBound^6 := by |
| rw [hv] |
| exact add_le_add (Nat.mul_le_mul_right _ he) (le_refl _) |
| _ = atomSizeConstant*(n+1)^3 := by unfold atomSizeConstant; ring |
|
|
| end |
|
|
| end WitnessedSeparation.Grid |
|
|
|
|
|
|
| namespace WitnessedSeparation.Hereditary |
|
|
| noncomputable section |
|
|
| open Classical |
|
|
| variable {A G : Type*} [Group G] [MulAction G A] {s : ℕ} |
|
|
| theorem hereditary_iff {x : HF A} : HereditarilySupported (G := G) s x ↔ |
| Supported (G := G) s x ∧ ∀ y, y ∈ x → HereditarilySupported (G := G) s y := by |
| constructor |
| · intro h |
| exact ⟨h x .refl,fun y hy z hz => h z (hz.tail hy)⟩ |
| · rintro ⟨h,hm⟩ y hy |
| cases hy with |
| | refl => exact h |
| | tail hz hzx => exact hm _ hzx _ hz |
|
|
| theorem hereditary_transitive {x y : HF A} (hx : HereditarilySupported (G := G) s x) (hy : y ∈ x) : |
| HereditarilySupported (G := G) s y := (hereditary_iff.mp hx).2 y hy |
|
|
| theorem ordinal_hereditary [Nonempty A] (s j : ℕ) : |
| HereditarilySupported (G := G) s (ordinal (A := A) j) := by |
| induction j using Nat.strong_induction_on with |
| | h j ih => |
| apply hereditary_iff.mpr |
| constructor |
| · refine ⟨fun _ => Classical.choice (inferInstance : Nonempty A),?_⟩ |
| intro g _ |
| exact map_ordinal (fun a => g • a) j |
| · intro y hy |
| obtain ⟨k,hk,rfl⟩ := (mem_ordinal y j).mp hy |
| exact ih k hk |
|
|
| end |
|
|
| end WitnessedSeparation.Hereditary |
|
|
|
|
|
|
| namespace WitnessedSeparation.Grid |
|
|
| noncomputable section |
|
|
| open Classical Hereditary Counting HFCoding Interpretations |
|
|
| variable {n : ℕ} (b : Vertex n → Scalar) |
|
|
| abbrev programInput : Interpretations.Structure Symbol where |
| Carrier := Atom b |
| finite := inferInstance |
| rel := (atomInput b).rel |
|
|
| def programActionIso (g : BoxGroup n) : (programInput b).Iso (programInput b) where |
| equiv := (actionIso (b := b) g).toEquiv |
| rel r x y := ((actionIso (b := b) g).rel_eq r x y).symm |
|
|
| variable (P : Interpretations.Program Symbol) |
|
|
| theorem trace_supported (hn : 1 ≤ n) (B K N : ℕ) (hB : 2 ≤ B) (hK : K ≤ B) |
| (hN : Nat.card (Atom b) ≤ B) (hNpos : 0 < N) |
| (hsize : ∀ j < K, Nat.card (P.state (programInput b) j).Carrier ≤ B) |
| (q : ℝ) (hq : 0 ≤ q) (hpoly : (9*B^3 : ℝ) ≤ (N : ℝ)^q) : |
| ∀ x ∈ P.family (programInput b) B K, |
| HereditarilySupported (G := CentralGroup n) ⌈2*(n+1:ℝ)*(q*Real.logb 3 N)^2⌉₊ x := by |
| obtain ⟨hc,ht,hi⟩ := P.trace_family (programInput b) B K hB hK hN hsize |
| have hInv : ∀ g : BoxGroup n, ∀ x ∈ P.family (programInput b) B K, |
| g • x ∈ P.family (programInput b) B K := by |
| intro g x hx |
| exact hi (programActionIso b g) x hx |
| exact invariant_family_hereditarily_supported hn _ hInv ht N hNpos q hq |
| (le_trans (by exact_mod_cast hc) hpoly) |
|
|
| variable {ι : Type} (bs : ι → Vertex n → Scalar) {s m : ℕ} |
|
|
| def programDomain (i : ι) : Set (HF (Atom (bs i))) := HereditarilySupported (G := CentralGroup n) s |
|
|
| def programHF (i : ι) : Counting.Structure (Forms.HFRelation AnalysisSymbol) (Domain (programDomain bs (s := s) i)) := |
| Forms.hfStructure (analysisStructure (bs i)) |
|
|
| theorem program_domain_transitive (i : ι) : |
| ∀ x ∈ programDomain bs (s := s) i, ∀ y, y ∈ x → y ∈ programDomain bs (s := s) i := |
| fun _ hx _ hy => hereditary_transitive hx hy |
|
|
| theorem program_mem_uniform : UniformDefinable (programHF bs (s := s)) m 2 |
| (fun _ v => (v 0).val ∈ (v 1).val) := |
| UniformDefinable.relation (S := programHF bs (s := s)) .mem 0 1 |
|
|
| theorem program_set_uniform : UniformDefinable (programHF bs (s := s)) m 1 |
| (fun _ v => isSet (v 0).val = true) := by |
| apply (UniformDefinable.relation (S := programHF bs (s := s)) .atom 0 0).neg.congr |
| intro i v |
| change (¬ isSet (v 0).val = false) ↔ _ |
| cases isSet (v 0).val <;> simp |
|
|
| theorem program_pure (hn : 1 ≤ n) (i : ι) (k : ℕ) : ordinal k ∈ programDomain bs (s := s) i := by |
| let := atom_nonempty hn (bs i) |
| exact ordinal_hereditary s k |
|
|
| variable {B K : ℕ} |
|
|
| variable (hfamily : ∀ i x, x ∈ P.family (programInput (bs i)) B K → x ∈ programDomain bs (s := s) i) |
|
|
| theorem program_input_definable : StateDefinable (fun i => programInput (bs i)) (programHF bs) |
| (P.inputCode (fun i => programInput (bs i)) hfamily) m := by |
| constructor |
| · apply (UniformDefinable.relation (S := programHF bs) .atom 0 0).congr |
| intro i v |
| change isSet (v 0).val = false ↔ ∃ a, _ |
| constructor |
| · intro hx |
| rcases atom_or_set (v 0).val with ⟨a,ha⟩|ha |
| · exact ⟨a,Subtype.ext ha.symm⟩ |
| · rw [ha,isSet_ofFinset] at hx |
| cases hx |
| · rintro ⟨a,ha⟩ |
| rw [← congrArg Subtype.val ha] |
| rfl |
| · intro r |
| apply (UniformDefinable.relation (S := programHF bs) (.base (.input r)) 0 1).congr |
| intro i v |
| change (∃ a b, (v 0).val = atom a ∧ (v 1).val = atom b ∧ AtomRelation (bs i) r a b) ↔ _ |
| apply exists_congr |
| intro a |
| apply exists_congr |
| intro b |
| refine and_congr ?_ (and_congr ?_ ?_) |
| · exact ⟨fun h => Subtype.ext h.symm,fun h => (congrArg Subtype.val h).symm⟩ |
| · exact ⟨fun h => Subtype.ext h.symm,fun h => (congrArg Subtype.val h).symm⟩ |
| · simp [atomInput] |
|
|
| end |
|
|
|
|
|
|
|
|
|
|
| noncomputable section |
|
|
| open Classical Hereditary Counting HFCoding Interpretations |
|
|
| variable {n B K N m M : ℕ} (P : Program Symbol) (vstar : Vertex n) |
|
|
| def twoCharges : Bool → Vertex n → Scalar |
| | false => 0 |
| | true => Pi.single vstar 1 |
|
|
| variable (hn : 1 ≤ n) (hB : 2 ≤ B) (hK : K ≤ B) (hNpos : 0 < N) |
|
|
| variable (hN : ∀ i, Nat.card (Atom (twoCharges vstar i)) ≤ B) |
|
|
| variable (hsize : ∀ i j, j < K → Nat.card (P.state (programInput (twoCharges vstar i)) j).Carrier ≤ B) |
|
|
| variable (q : ℝ) (hq : 0 ≤ q) (hpoly : (9*B^3 : ℝ) ≤ (N : ℝ)^q) |
|
|
| variable (hm : 6 ≤ m) |
|
|
| variable (wiδ : P.init.domain.scopedWidth < m) (wiη : P.init.identify.scopedWidth < m) |
|
|
| variable (wiρ : ∀ r, (P.init.relation r).scopedWidth < m) |
|
|
| variable (wsδ : P.step.domain.scopedWidth < m) (wsη : P.step.identify.scopedWidth < m) |
|
|
| variable (wsρ : ∀ r, (P.step.relation r).scopedWidth < m) |
|
|
| include hn hB hK hNpos hN hsize hq hpoly hm wiδ wiη wiρ wsδ wsη wsρ |
|
|
| theorem stage_sentence_agrees |
| (hs : 0 < ⌈2*(n+1:ℝ)*(q*Real.logb 3 N)^2⌉₊) |
| (hwidth : max 4 (m+1)*⌈2*(n+1:ℝ)*(q*Real.logb 3 N)^2⌉₊ ≤ M) |
| (hhom : (7*(max 2 m*⌈2*(n+1:ℝ)*(q*Real.logb 3 N)^2⌉₊):ℝ)+ |
| 7*((6*(max 2 m*⌈2*(n+1:ℝ)*(q*Real.logb 3 N)^2⌉₊):ℝ)/boxConstant)^((3:ℝ)/2)+1 ≤ M) |
| (hgiant : GiantBound n M) |
| {j : ℕ} (hj : j < K) (ψ : Interpretations.Formula P.StateSymbols 0) (hw : ψ.scopedWidth < m) : |
| ψ.holds (P.state (programInput (0 : Vertex n → Scalar)) j) ↔ |
| ψ.holds (P.state (programInput (Pi.single vstar 1)) j) := by |
| let s := ⌈2*(n+1:ℝ)*(q*Real.logb 3 N)^2⌉₊ |
| let S := fun i => programInput (twoCharges vstar i) |
| let C := programHF (twoCharges vstar) (s := s) |
| have hfamily : ∀ i x, x ∈ P.family (S i) B K → x ∈ programDomain (twoCharges vstar) (s := s) i := |
| fun i => trace_supported (twoCharges vstar i) P hn B K N hB hK (hN i) hNpos |
| (hsize i) q hq hpoly |
| have hd := P.state_definable S C hfamily (program_domain_transitive (twoCharges vstar)) |
| (program_mem_uniform (twoCharges vstar)) (program_set_uniform (twoCharges vstar)) hm |
| (program_pure (twoCharges vstar) hn) hN hsize wiδ wiη wiρ wsδ wsη wsρ |
| (program_input_definable P (twoCharges vstar) hfamily) hj |
| obtain ⟨φ,hφ,hφψ⟩ := hd.sentence (fun i => P.state (S i) j) C (P.stateCode S hfamily hj) |
| (P.stateCode_injective S hfamily hj) (fun i => hsize i j hj) ψ hw |
| let v : Fin m → Domain (programDomain (twoCharges vstar) (s := s) false) := |
| fun _ => ⟨ordinal 0,program_pure (twoCharges vstar) hn false 0⟩ |
| let w : Fin m → Domain (programDomain (twoCharges vstar) (s := s) true) := |
| fun _ => ⟨ordinal 0,program_pure (twoCharges vstar) hn true 0⟩ |
| let := atom_nonempty hn (0 : Vertex n → Scalar) |
| let := atom_nonempty hn (Pi.single vstar 1) |
| exact (hφψ false v).symm.trans ((grid_hf_transfer hn hs (by omega) vstar |
| hwidth hhom hgiant φ hφ v w).trans (hφψ true w)) |
|
|
| end |
|
|
| end WitnessedSeparation.Grid |
|
|
|
|
|
|
| namespace WitnessedSeparation.Quantitative |
|
|
| noncomputable section |
|
|
| open Filter Asymptotics Topology |
|
|
| lemma const_little_rpow (c : ℝ) {r : ℝ} (hr : 0 < r) : |
| (fun _ : ℝ => c) =o[atTop] (fun L => L^r) := |
| (isLittleO_const_id_atTop c).comp_tendsto (tendsto_rpow_atTop hr) |
|
|
| lemma power_little_power {a b : ℝ} (hab : a < b) : |
| (fun L : ℝ => L^a) =o[atTop] (fun L => L^b) := by |
| have h := (isBigO_refl (fun L : ℝ => L^a) atTop).mul_isLittleO (const_little_rpow 1 (sub_pos.mpr hab)) |
| apply h.congr' (by filter_upwards [] with L; simp) |
| filter_upwards [eventually_gt_atTop (0:ℝ)] with L hL |
| rw [← Real.rpow_add hL] |
| congr 1 |
| ring |
| |
| lemma ceil_little {α : Type*} {l : Filter α} {f g : α → ℝ} |
| (hf : ∀ᶠ x in l, 0 ≤ f x) (h : f =o[l] g) (h1 : (fun _ => (1:ℝ)) =o[l] g) : |
| (fun x => (⌈f x⌉₊ : ℝ)) =o[l] g := by |
| apply IsLittleO.of_bound |
| intro c hc |
| filter_upwards [hf,h.bound (show 0 < c/2 by linarith),h1.bound (show 0 < c/2 by linarith)] with x hx hh hconst |
| rw [Real.norm_of_nonneg (Nat.cast_nonneg _)] |
| rw [Real.norm_of_nonneg hx] at hh |
| norm_num at hconst |
| have hb := Nat.ceil_lt_add_one hx |
| simp only [Real.norm_eq_abs] at hh ⊢ |
| linarith |
| |
| def radius (C q L : ℝ) : ℕ := ⌈2*L*(q*Real.logb 3 (C*L^3))^2⌉₊ |
| |
| def palette (L : ℝ) : ℕ := ⌊L^((7:ℝ)/4)⌋₊ |
| |
| lemma log_volume_little (C q : ℝ) (hC : 0 < C) : |
| (fun L : ℝ => q*Real.logb 3 (C*L^3)) =o[atTop] (fun L => L^((1:ℝ)/12)) := by |
| have hc := const_little_rpow (Real.log C) (show 0 < (1:ℝ)/12 by norm_num) |
| have hl := (isLittleO_log_rpow_atTop (show 0 < (1:ℝ)/12 by norm_num)).const_mul_left 3 |
| have h := ((hc.add hl).const_mul_left ((q:ℝ)/Real.log 3)) |
| apply h.congr' _ (Filter.Eventually.of_forall (fun _ => rfl)) |
| filter_upwards [eventually_gt_atTop (0:ℝ)] with L hL |
| simp only [Real.logb,Real.log_mul (ne_of_gt hC) (ne_of_gt (pow_pos hL 3)),Real.log_pow] |
| ring |
|
|
| lemma radius_little (C q : ℝ) (hC : 0 < C) : |
| (fun L : ℝ => (radius C q L : ℝ)) =o[atTop] (fun L => L^((7:ℝ)/6)) := by |
| have hlog := log_volume_little C q hC |
| have hsquare := hlog.pow (show 0 < 2 by omega) |
| have hlin := (isBigO_refl (fun L : ℝ => L) atTop).mul_isLittleO hsquare |
| have hraw : (fun L : ℝ => 2*L*(q*Real.logb 3 (C*L^3))^2) =o[atTop] (fun L => L^((7:ℝ)/6)) := by |
| apply (hlin.const_mul_left 2).congr' (by filter_upwards [] with L; ring) |
| filter_upwards [eventually_gt_atTop (0:ℝ)] with L hL |
| calc |
| L * (L ^ ((1:ℝ)/12)) ^ 2 = L^((1:ℝ)) * L^(((1:ℝ)/12)*2) := by |
| rw [Real.rpow_one, Real.rpow_mul hL.le]; norm_num |
| _ = L^((7:ℝ)/6) := by rw [← Real.rpow_add hL]; norm_num |
| apply ceil_little _ hraw (const_little_rpow 1 (by norm_num)) |
| filter_upwards [eventually_ge_atTop (0:ℝ)] with L hL |
| positivity |
| |
| lemma radius_little_palette (C q : ℝ) (hC : 0 < C) : |
| (fun L : ℝ => (radius C q L : ℝ)) =o[atTop] (fun L => L^((7:ℝ)/4)) := |
| (radius_little C q hC).trans (power_little_power (by norm_num)) |
| |
| lemma homogeneity_little (C q m c : ℝ) (hC : 0 < C) : |
| (fun L : ℝ => 7*(m*(radius C q L:ℝ))+7*((6*(m*(radius C q L:ℝ)))/c)^((3:ℝ)/2)+1) |
| =o[atTop] (fun L => L^((7:ℝ)/4)) := by |
| have hlin := (radius_little_palette C q hC).const_mul_left (7*m) |
| have hsr := (radius_little C q hC).const_mul_left (6*m/c) |
| have hp := hsr.rpow (show 0 < (3:ℝ)/2 by norm_num) |
| ((eventually_ge_atTop (0:ℝ)).mono (fun L hL => Real.rpow_nonneg hL _)) |
| have hp' : (fun L : ℝ => ((6*(m*(radius C q L:ℝ)))/c)^((3:ℝ)/2)) |
| =o[atTop] (fun L => L^((7:ℝ)/4)) := by |
| apply hp.congr' (by filter_upwards [] with L; congr 1; ring) |
| filter_upwards [eventually_ge_atTop (0:ℝ)] with L hL |
| rw [← Real.rpow_mul hL] |
| congr 1 |
| norm_num |
| have h := (hlin.add (hp'.const_mul_left 7)).add (const_little_rpow 1 (by norm_num)) |
| apply h.congr_left |
| intro L |
| ring |
|
|
| lemma floor_big (a : ℝ) : (fun L : ℝ => (⌊L^a⌋₊:ℝ)) =O[atTop] (fun L => L^a) := by |
| apply IsBigO.of_norm_eventuallyLE |
| filter_upwards [eventually_ge_atTop (0:ℝ)] with L hL |
| simp only [Real.norm_of_nonneg (Nat.cast_nonneg _)] |
| exact Nat.floor_le (Real.rpow_nonneg hL _) |
|
|
| lemma giant_little (c : ℝ) : |
| (fun L : ℝ => ((12*(palette L:ℝ))/c)^((3:ℝ)/2)) =o[atTop] (fun L => L^3) := by |
| have hb := (floor_big ((7:ℝ)/4)).const_mul_left (12/c) |
| have hp := hb.rpow (show 0 ≤ (3:ℝ)/2 by norm_num) |
| ((eventually_ge_atTop (0:ℝ)).mono (fun L hL => Real.rpow_nonneg hL _)) |
| have hp' : (fun L : ℝ => ((12*(palette L:ℝ))/c)^((3:ℝ)/2)) =O[atTop] |
| (fun L => L^((21:ℝ)/8)) := by |
| apply hp.congr' (by filter_upwards [] with L; simp only [palette]; congr 1; ring) |
| filter_upwards [eventually_ge_atTop (0:ℝ)] with L hL |
| rw [← Real.rpow_mul hL] |
| congr 1 |
| norm_num |
| have h := hp'.trans_isLittleO (power_little_power (a := (21:ℝ)/8) (b := 3) (by norm_num)) |
| exact h.congr_right (fun L => Real.rpow_natCast L 3) |
| |
| theorem eventual_bounds (C q c : ℝ) (hC : 0 < C) (hc : 0 < c) (m : ℕ) : |
| ∀ᶠ L : ℝ in atTop, |
| (max 4 (m+1):ℝ)*(radius C q L:ℝ) ≤ (palette L:ℝ) ∧ |
| 7*((max 2 m:ℝ)*(radius C q L:ℝ))+ |
| 7*((6*((max 2 m:ℝ)*(radius C q L:ℝ)))/c)^((3:ℝ)/2)+1 ≤ (palette L:ℝ) ∧ |
| ((12*(palette L:ℝ))/c)^((3:ℝ)/2) < L^3 := by |
| have hw := ((radius_little_palette C q hC).const_mul_left (max 4 (m+1):ℝ)).bound |
| (show 0 < (1:ℝ)/2 by norm_num) |
| have hh := (homogeneity_little C q (max 2 m:ℝ) c hC).bound (show 0 < (1:ℝ)/2 by norm_num) |
| have hg := (giant_little c).bound (show 0 < (1:ℝ)/2 by norm_num) |
| filter_upwards [hw,hh,hg,eventually_gt_atTop (0:ℝ), |
| (tendsto_rpow_atTop (show 0 < (7:ℝ)/4 by norm_num)).eventually_ge_atTop 2] with L hw hh hg hL hpow |
| have hp : 0 ≤ L^((7:ℝ)/4) := Real.rpow_nonneg hL.le _ |
| have hs : 0 ≤ (radius C q L:ℝ) := Nat.cast_nonneg _ |
| have hfl := Nat.lt_floor_add_one (L^((7:ℝ)/4)) |
| have hn : 0 ≤ 7*((max 2 m:ℝ)*(radius C q L:ℝ))+ |
| 7*((6*((max 2 m:ℝ)*(radius C q L:ℝ)))/c)^((3:ℝ)/2)+1 := by positivity |
| rw [Real.norm_of_nonneg (by positivity),Real.norm_of_nonneg hp] at hw |
| rw [Real.norm_of_nonneg hn,Real.norm_of_nonneg hp] at hh |
| rw [Real.norm_of_nonneg (by positivity),Real.norm_of_nonneg (pow_nonneg hL.le 3)] at hg |
| change _ ≤ (⌊L^((7:ℝ)/4)⌋₊:ℝ) ∧ _ ≤ (⌊L^((7:ℝ)/4)⌋₊:ℝ) ∧ _ |
| refine ⟨by linarith,by linarith,?_⟩ |
| have hcube := pow_pos hL 3 |
| linarith |
| |
| end |
| |
| |
| |
| |
| |
| def timeExponent (c d : ℕ) := c + 2*d + 2 |
| |
| def traceExponent (c d : ℕ) := 3*timeExponent c d + 4 |
| |
| lemma timeExponent_ge_two (c d : ℕ) : 2 ≤ timeExponent c d := by unfold timeExponent; omega |
| |
| lemma nat_le_power (N c : ℕ) (hN : 2 ≤ N) : c ≤ N^c := by |
| induction c with |
| | zero => simp |
| | succ c ih => |
| rw [pow_succ] |
| have hp : 1 ≤ N^c := Nat.one_le_pow _ _ (by omega) |
| nlinarith |
| |
| lemma polynomial_bounds (c d N : ℕ) (hN : 2 ≤ N) : |
| 2 ≤ N^timeExponent c d ∧ N ≤ N^timeExponent c d ∧ |
| c*(N+1)^d ≤ N^timeExponent c d ∧ |
| 9*(N^timeExponent c d)^3 ≤ N^traceExponent c d := by |
| have hpos : 1 ≤ N := by omega |
| have hD := timeExponent_ge_two c d |
| have hNB : N ≤ N^timeExponent c d := by |
| simpa only [pow_one] using Nat.pow_le_pow_right hpos (show 1 ≤ timeExponent c d by omega) |
| refine ⟨le_trans hN hNB,hNB,?_,?_⟩ |
| · calc |
| c*(N+1)^d ≤ N^c*(N^2)^d := Nat.mul_le_mul (nat_le_power N c hN) |
| (Nat.pow_le_pow_left (by nlinarith : N+1 ≤ N^2) d) |
| _ = N^(c+2*d) := by rw [← pow_mul,← pow_add] |
| _ ≤ N^timeExponent c d := Nat.pow_le_pow_right hpos (by unfold timeExponent; omega) |
| · calc |
| 9*(N^timeExponent c d)^3 ≤ N^4*(N^timeExponent c d)^3 := by |
| apply Nat.mul_le_mul_right |
| have hh := Nat.pow_le_pow_left hN 4 |
| norm_num at hh |
| omega |
| _ = N^traceExponent c d := by |
| rw [← pow_mul,← pow_add] |
| unfold traceExponent |
| congr 1 |
| omega |
| |
| lemma real_trace_bound (c d N : ℕ) (hN : 2 ≤ N) : |
| (9*(N^timeExponent c d)^3 : ℝ) ≤ (N:ℝ)^(traceExponent c d:ℝ) := by |
| rw [Real.rpow_natCast] |
| exact_mod_cast (polynomial_bounds c d N hN).2.2.2 |
| |
| end WitnessedSeparation.Quantitative |
| |
| |
| |
| namespace WitnessedSeparation.Interpretations.Program |
| |
| noncomputable section |
| |
| open Classical Finset |
| |
| variable {R : Type} (P : Program R) |
| |
| lemma stage_le_cost (A : Structure R) (j : ℕ) : j+1 ≤ P.cost A j := by |
| unfold cost |
| omega |
| |
| lemma size_le_cost (A : Structure R) {j k : ℕ} (hk : k ≤ j) : |
| Nat.card (P.state A k).Carrier ≤ P.cost A j := by |
| rw [Nat.card_eq_fintype_card] |
| unfold cost |
| have h := Finset.single_le_sum (f := fun l => Fintype.card (P.state A l).Carrier) |
| (fun l _ => Nat.zero_le _) (show k ∈ Finset.range (j+1) by simpa using hk) |
| omega |
| |
| end |
| |
| end WitnessedSeparation.Interpretations.Program |
| |
| end OAI |
| |
