Download data/lean/OAI/Computability/WitnessedChoice/EncodedCounting.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 49.9 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/WitnessedChoice/EncodedCounting.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Computability/WitnessedChoice/EncodedCounting.lean
-
curl -L -o EncodedCounting.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/WitnessedChoice/EncodedCounting.lean
49.9 kB
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 // p a} ≤ 4 := by
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 // cycle (.inl f) e ≠ 0} ≤ 4 := by
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 // cycle (.inr (.inl f)) e ≠ 0} ≤ 4 := by
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 // cycle (.inr (.inr f)) e ≠ 0} ≤ 4 := by
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
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