| import OAI.Computability.WitnessedChoice.ChoiceTrace |
|
|
| namespace OAI |
|
|
| section |
|
|
| namespace WitnessedChoice.BGS |
|
|
| noncomputable section |
|
|
| open Classical WitnessedSeparation WitnessedSeparation.Hereditary WitnessedSeparation.HFCoding |
|
|
| variable {A : Type} |
|
|
| def LoopGraph (d : Set (HF A)) (p : ℕ) {n : ℕ} |
| (step : Domain d → (Fin (n+1) → Domain d) → Prop) : |
| ℕ → Domain d → Domain d → (Fin n → Domain d) → Prop |
| | 0, z, _, _ => z.val = emptyHF |
| | fuel+1, z, x, env => |
| ((TC x.val).card > p ∧ z.val = emptyHF) ∨ |
| ((TC x.val).card ≤ p ∧ ∃ y : Domain d, step y (Fin.cons x env) ∧ |
| ((x = y ∧ z = x) ∨ (x ≠ y ∧ LoopGraph d p step fuel z y env))) |
|
|
| mutual |
| def Term.Graph [Fintype A] (d : Set (HF A)) (S : Input A) (p K : ℕ) : |
| {n : ℕ} → Term n → Domain d → (Fin n → Domain d) → Prop |
| | _, .var j, z, env => z = env j |
| | _, .empty, z, _ => z.val = emptyHF |
| | _, .atoms, z, _ => z.val = ofFinset (Finset.univ.image atom) |
| | _, .pair a b, z, env => ∃ x y : Domain d, |
| a.Graph d S p K x env ∧ b.Graph d S p K y env ∧ z.val = double x.val y.val |
| | _, .union a, z, env => ∃ x : Domain d, a.Graph d S p K x env ∧ z.val = unionHF x.val |
| | _, .unique a, z, env => ∃ x : Domain d, a.Graph d S p K x env ∧ z.val = uniqueHF x.val |
| | _, .card a, z, env => ∃ x : Domain d, a.Graph d S p K x env ∧ |
| (elements x.val).card ≤ K ∧ z.val = cardHF x.val |
| | _, .comprehend body range guard, z, env => ∃ r : Domain d, |
| range.Graph d S p K r env ∧ |
| (∀ x : Domain d, x.val ∈ r.val → ∃ b : Bool, |
| guard.Graph d S p K b (Fin.cons x env) ∧ |
| (b = true → ∃ y : Domain d, body.Graph d S p K y (Fin.cons x env))) ∧ |
| isSet z.val = true ∧ ∀ y : Domain d, y.val ∈ z.val ↔ ∃ x : Domain d, |
| x.val ∈ r.val ∧ guard.Graph d S p K true (Fin.cons x env) ∧ |
| body.Graph d S p K y (Fin.cons x env) |
| | _, .iterate step, z, env => ∃ x : Domain d, x.val = emptyHF ∧ |
| LoopGraph d p (step.Graph d S p K) (p+1) z x env |
| def Formula.Graph [Fintype A] (d : Set (HF A)) (S : Input A) (p K : ℕ) : |
| {n : ℕ} → Formula n → Bool → (Fin n → Domain d) → Prop |
| | _, .equal a b, v, env => ∃ x y : Domain d, |
| a.Graph d S p K x env ∧ b.Graph d S p K y env ∧ v = decide (x.val = y.val) |
| | _, .input r a b, v, env => ∃ x y : Domain d, |
| a.Graph d S p K x env ∧ b.Graph d S p K y env ∧ v = inputHF S r x.val y.val |
| | _, .neg a, v, env => ∃ b : Bool, a.Graph d S p K b env ∧ v = !b |
| | _, .and a b, v, env => ∃ c e : Bool, a.Graph d S p K c env ∧ |
| b.Graph d S p K e env ∧ v = (c && e) |
| | _, .or a b, v, env => ∃ c e : Bool, a.Graph d S p K c env ∧ |
| b.Graph d S p K e env ∧ v = (c || e) |
| | _, .wsc _ _ _ _, _, _ => False |
| end |
|
|
| lemma domain_cons_val {d : Set (HF A)} {n : ℕ} (x : Domain d) (env : Fin n → Domain d) : |
| (fun j => ((Fin.cons x env : Fin (_+1) → Domain d) j).val) = Fin.cons x.val (fun j => (env j).val) := by |
| funext j |
| exact Fin.cases rfl (fun _ => rfl) j |
|
|
| lemma LoopGraph.sound {d : Set (HF A)} (p : ℕ) {n : ℕ} |
| (step : Domain d → (Fin (n+1) → Domain d) → Prop) |
| (ts : HF A → Traced A (HF A)) (env : Fin n → Domain d) |
| (hs : ∀ x y : Domain d, step y (Fin.cons x env) → y.val = (ts x.val).1) |
| (fuel : ℕ) (z x : Domain d) (h : LoopGraph d p step fuel z x env) : |
| z.val = (tracedLoop p ts fuel x.val).1 := by |
| induction fuel generalizing z x with |
| | zero => exact h |
| | succ fuel ih => |
| rcases h with ⟨hb,hz⟩ | ⟨hb,y,hy,he⟩ |
| · simpa only [tracedLoop,ite_eq_right (by omega : ¬ (TC x.val).card ≤ p)] using hz |
| · have hval := hs x y hy |
| rcases he with ⟨rfl,rfl⟩ | ⟨hne,hrec⟩ |
| · simp only [tracedLoop,ite_eq_left hb,ite_eq_left hval] |
| · have hn : x.val ≠ (ts x.val).1 := fun h => hne (Subtype.ext (h.trans hval.symm)) |
| simp only [tracedLoop,ite_eq_left hb,ite_eq_right hn] |
| rw [← hval] |
| exact ih z y hrec |
|
|
| variable [Fintype A] |
|
|
| mutual |
| lemma Term.graph_sound (d : Set (HF A)) (S : Input A) (p K : ℕ) |
| (hd : ∀ x ∈ d, ∀ y, y ∈ x → y ∈ d) {n : ℕ} |
| (t : Term n) (z : Domain d) (env : Fin n → Domain d) |
| (h : t.Graph d S p K z env) : z.val = (t.traced S p (fun j => (env j).val)).1 := by |
| cases t with |
| | var j => exact congrArg Subtype.val h |
| | empty => exact h |
| | atoms => exact h |
| | pair a b => |
| obtain ⟨x,y,hx,hy,hz⟩ := h |
| change z.val = double (a.traced S p (fun j => (env j).val)).1 |
| (b.traced S p (fun j => (env j).val)).1 |
| exact hz.trans (congrArg₂ double (a.graph_sound d S p K hd x env hx) |
| (b.graph_sound d S p K hd y env hy)) |
| | union a => |
| obtain ⟨x,hx,hz⟩ := h |
| exact hz.trans (congrArg unionHF (a.graph_sound d S p K hd x env hx)) |
| | unique a => |
| obtain ⟨x,hx,hz⟩ := h |
| exact hz.trans (congrArg uniqueHF (a.graph_sound d S p K hd x env hx)) |
| | card a => |
| obtain ⟨x,hx,_,hz⟩ := h |
| exact hz.trans (congrArg cardHF (a.graph_sound d S p K hd x env hx)) |
| | comprehend body range guard => |
| obtain ⟨r,hr,hall,hz,hmem⟩ := h |
| have her := range.graph_sound d S p K hd r env hr |
| apply ext_sets hz (isSet_ofFinset _) |
| intro y |
| simp only [mem_ofFinset,Finset.mem_image,Finset.mem_filter] |
| constructor |
| · intro hy |
| obtain ⟨x,hx,hg,hb⟩ := (hmem ⟨y,hd _ z.property _ hy⟩).mp hy |
| refine ⟨x.val,⟨by rwa [← her],?_⟩,?_⟩ |
| · have hh := guard.graph_sound d S p K hd true (Fin.cons x env) hg |
| simpa only [domain_cons_val] using hh.symm |
| · have hh := body.graph_sound d S p K hd ⟨y,hd _ z.property _ hy⟩ (Fin.cons x env) hb |
| simpa only [domain_cons_val] using hh.symm |
| · rintro ⟨x,⟨hxr,hgt⟩,hey⟩ |
| have hxd : x ∈ d := hd _ r.property _ (by rwa [her]) |
| let xx : Domain d := ⟨x,hxd⟩ |
| have hxx : xx.val ∈ r.val := by change x ∈ r.val; rwa [her] |
| obtain ⟨v,hv,hbody⟩ := hall xx hxx |
| have he := guard.graph_sound d S p K hd v (Fin.cons xx env) hv |
| simp only [domain_cons_val] at he |
| have hvt : v = true := he.trans hgt |
| obtain ⟨w,hw⟩ := hbody hvt |
| have hew := body.graph_sound d S p K hd w (Fin.cons xx env) hw |
| simp only [domain_cons_val] at hew |
| have hwval : w.val = y := hew.trans hey |
| have hyd : y ∈ d := hwval ▸ w.property |
| apply (hmem ⟨y,hyd⟩).mpr |
| refine ⟨xx,hxx,hvt ▸ hv,?_⟩ |
| have heq : w = (⟨y,hyd⟩ : Domain d) := Subtype.ext hwval |
| rwa [← heq] |
| | iterate step => |
| obtain ⟨x,hx,hl⟩ := h |
| have hh := LoopGraph.sound p (step.Graph d S p K) |
| (fun y => step.traced S p (Fin.cons y (fun j => (env j).val))) env |
| (fun x y h => by simpa only [domain_cons_val] using |
| step.graph_sound d S p K hd y (Fin.cons x env) h) (p+1) z x hl |
| simpa only [Term.traced,hx] using hh |
| termination_by sizeOf t |
| decreasing_by all_goals subst_vars; simp_wf <;> omega |
| lemma Formula.graph_sound (d : Set (HF A)) (S : Input A) (p K : ℕ) |
| (hd : ∀ x ∈ d, ∀ y, y ∈ x → y ∈ d) {n : ℕ} |
| (f : Formula n) (v : Bool) (env : Fin n → Domain d) |
| (h : f.Graph d S p K v env) : v = (f.traced S p (fun j => (env j).val)).1 := by |
| cases f with |
| | equal a b => |
| obtain ⟨x,y,hx,hy,hv⟩ := h |
| exact hv.trans (congrArg₂ (fun x y : HF A => decide (x = y)) |
| (a.graph_sound d S p K hd x env hx) (b.graph_sound d S p K hd y env hy)) |
| | input r a b => |
| obtain ⟨x,y,hx,hy,hv⟩ := h |
| exact hv.trans (congrArg₂ (inputHF S r) |
| (a.graph_sound d S p K hd x env hx) (b.graph_sound d S p K hd y env hy)) |
| | neg a => |
| obtain ⟨b,hb,hv⟩ := h |
| change v = !(a.traced S p (fun j => (env j).val)).1 |
| exact hv.trans (congrArg Bool.not (a.graph_sound d S p K hd b env hb)) |
| | and a b => |
| obtain ⟨c,e,hc,he,hv⟩ := h |
| exact hv.trans (congrArg₂ Bool.and (a.graph_sound d S p K hd c env hc) |
| (b.graph_sound d S p K hd e env he)) |
| | or a b => |
| obtain ⟨c,e,hc,he,hv⟩ := h |
| exact hv.trans (congrArg₂ Bool.or (a.graph_sound d S p K hd c env hc) |
| (b.graph_sound d S p K hd e env he)) |
| | wsc step choice witness output => exact h.elim |
| termination_by sizeOf f |
| decreasing_by all_goals subst_vars; simp_wf <;> omega |
| end |
| |
| end |
| |
| end WitnessedChoice.BGS |
| |
| namespace WitnessedChoice.BGS |
| |
| noncomputable section |
| |
| open Classical WitnessedSeparation WitnessedSeparation.Hereditary WitnessedSeparation.HFCoding |
| |
| variable {A : Type} |
|
|
| def AdmissibleTrace (d : Set (HF A)) (K : ℕ) (F : Finset (HF A)) : Prop := |
| ∀ x ∈ F, x ∈ d ∧ (elements x).card ≤ K |
|
|
| lemma AdmissibleTrace.mono {d : Set (HF A)} {K : ℕ} {F G : Finset (HF A)} |
| (h : AdmissibleTrace d K F) (hg : G ⊆ F) : AdmissibleTrace d K G := |
| fun x hx => h x (hg hx) |
|
|
| lemma admissibleTrace_of_closed {F : Finset (HF A)} (hF : ClosedTrace F) : |
| AdmissibleTrace (F : Set (HF A)) F.card F := by |
| intro x hx |
| exact ⟨hx,Finset.card_le_card ((elements_subset_closure x).trans (hF x hx))⟩ |
|
|
| lemma LoopGraph.complete {d : Set (HF A)} (p K : ℕ) {n : ℕ} |
| (step : Domain d → (Fin (n+1) → Domain d) → Prop) |
| (ts : HF A → Traced A (HF A)) (env : Fin n → Domain d) |
| (hout : ∀ x, (ts x).1 ∈ (ts x).2) |
| (hs : ∀ x y : Domain d, AdmissibleTrace d K (ts x.val).2 → |
| y.val = (ts x.val).1 → step y (Fin.cons x env)) |
| (fuel : ℕ) (z x : Domain d) |
| (ht : AdmissibleTrace d K (tracedLoop p ts fuel x.val).2) |
| (hz : z.val = (tracedLoop p ts fuel x.val).1) : |
| LoopGraph d p step fuel z x env := by |
| induction fuel generalizing z x with |
| | zero => exact hz |
| | succ fuel ih => |
| by_cases hb : (TC x.val).card ≤ p |
| · have htstep : AdmissibleTrace d K (ts x.val).2 := by |
| simp only [tracedLoop,ite_eq_left hb] at ht |
| split_ifs at ht with he |
| · exact ht |
| · exact ht.mono Finset.subset_union_left |
| let y : Domain d := ⟨(ts x.val).1,(htstep _ (hout _)).1⟩ |
| refine Or.inr ⟨hb,y,hs x y htstep rfl,?_⟩ |
| by_cases he : x.val = (ts x.val).1 |
| · left |
| exact ⟨Subtype.ext he,Subtype.ext (by simpa only [tracedLoop,ite_eq_left hb,ite_eq_left he] using hz)⟩ |
| · right |
| refine ⟨fun h => he (congrArg Subtype.val h),?_⟩ |
| apply ih z y |
| · exact ht.mono (by simp only [tracedLoop,ite_eq_left hb,ite_eq_right he]; exact Finset.subset_union_right) |
| · simpa only [tracedLoop,ite_eq_left hb,ite_eq_right he] using hz |
| · exact Or.inl ⟨by omega,by simpa only [tracedLoop,ite_eq_right hb] using hz⟩ |
| |
| variable [Fintype A] |
| |
| mutual |
| lemma Term.graph_complete (d : Set (HF A)) (S : Input A) (p K : ℕ) |
| (hd : ∀ x ∈ d, ∀ y, y ∈ x → y ∈ d) (hempty : emptyHF ∈ d) {n : ℕ} (t : Term n) (hzero : t.wscCount = 0) |
| (z : Domain d) (env : Fin n → Domain d) |
| (ht : AdmissibleTrace d K (t.traced S p (fun j => (env j).val)).2) |
| (hz : z.val = (t.traced S p (fun j => (env j).val)).1) : t.Graph d S p K z env := by |
| cases t with |
| | var j => exact Subtype.ext hz |
| | empty => exact hz |
| | atoms => exact hz |
| | pair a b => |
| have h := Nat.add_eq_zero_iff.mp hzero |
| have ha := ht.mono (Finset.subset_union_left.trans (Finset.subset_insert _ _)) |
| have hb := ht.mono (Finset.subset_union_right.trans (Finset.subset_insert _ _)) |
| let x : Domain d := ⟨(a.traced S p (fun j => (env j).val)).1,(ha _ (a.traced_self S p _)).1⟩ |
| let y : Domain d := ⟨(b.traced S p (fun j => (env j).val)).1,(hb _ (b.traced_self S p _)).1⟩ |
| exact ⟨x,y,a.graph_complete d S p K hd hempty h.1 x env ha rfl, |
| b.graph_complete d S p K hd hempty h.2 y env hb rfl,hz⟩ |
| | union a | unique a => |
| have ha := ht.mono (Finset.subset_insert _ _) |
| let x : Domain d := ⟨(a.traced S p (fun j => (env j).val)).1,(ha _ (a.traced_self S p _)).1⟩ |
| exact ⟨x,a.graph_complete d S p K hd hempty hzero x env ha rfl,hz⟩ |
| | card a => |
| have ha := ht.mono Finset.subset_union_right |
| let x : Domain d := ⟨(a.traced S p (fun j => (env j).val)).1,(ha _ (a.traced_self S p _)).1⟩ |
| exact ⟨x,a.graph_complete d S p K hd hempty hzero x env ha rfl, |
| (ha _ (a.traced_self S p _)).2,hz⟩ |
| | comprehend body range guard => |
| have h := Nat.add_eq_zero_iff.mp hzero |
| have h' := Nat.add_eq_zero_iff.mp h.1 |
| have hr := ht.mono (Finset.subset_union_left.trans |
| (Finset.subset_union_left.trans (Finset.subset_insert _ _))) |
| let r : Domain d := ⟨(range.traced S p (fun j => (env j).val)).1, |
| (hr _ (range.traced_self S p _)).1⟩ |
| have hg (x : Domain d) (hx : x.val ∈ r.val) : |
| AdmissibleTrace d K (guard.traced S p (fun j => ((Fin.cons x env : Fin (_+1) → Domain d) j).val)).2 := by |
| rw [domain_cons_val] |
| apply ht.mono |
| intro y hy |
| exact Finset.mem_insert_of_mem (Finset.mem_union_left _ |
| (Finset.mem_union_right _ (Finset.mem_biUnion.mpr ⟨x.val,hx,hy⟩))) |
| have hb (x : Domain d) (hx : x.val ∈ r.val) |
| (hxg : (guard.traced S p (fun j => ((Fin.cons x env : Fin (_+1) → Domain d) j).val)).1 = true) : |
| AdmissibleTrace d K (body.traced S p (fun j => ((Fin.cons x env : Fin (_+1) → Domain d) j).val)).2 := by |
| rw [domain_cons_val] at hxg ⊢ |
| apply ht.mono |
| intro y hy |
| exact Finset.mem_insert_of_mem (Finset.mem_union_right _ |
| (Finset.mem_biUnion.mpr ⟨x.val,Finset.mem_filter.mpr ⟨hx,hxg⟩,hy⟩)) |
| refine ⟨r,range.graph_complete d S p K hd hempty h'.2 r env hr rfl,?_,?_,?_⟩ |
| · intro x hx |
| refine ⟨(guard.traced S p (fun j => ((Fin.cons x env : Fin (_+1) → Domain d) j).val)).1, |
| guard.graph_complete d S p K hd hempty h.2 _ _ (hg x hx) rfl,?_⟩ |
| intro hxg |
| let y : Domain d := ⟨(body.traced S p (fun j => ((Fin.cons x env : Fin (_+1) → Domain d) j).val)).1, |
| ((hb x hx hxg) _ (body.traced_self S p _)).1⟩ |
| exact ⟨y,body.graph_complete d S p K hd hempty h'.1 y _ (hb x hx hxg) rfl⟩ |
| · rw [hz]; exact isSet_ofFinset _ |
| · intro y |
| rw [hz] |
| change y.val ∈ ofFinset _ ↔ _ |
| simp only [mem_ofFinset,Finset.mem_image,Finset.mem_filter] |
| constructor |
| · rintro ⟨x,⟨hx,hxg⟩,hy⟩ |
| have hxd : x ∈ d := (hr x (range.traced_closure S p _ (elements_subset_closure _ hx))).1 |
| let xx : Domain d := ⟨x,hxd⟩ |
| have hxg' : (guard.traced S p (fun j => ((Fin.cons xx env : Fin (_+1) → Domain d) j).val)).1 = true := by |
| simpa only [domain_cons_val] using hxg |
| refine ⟨xx,hx,guard.graph_complete d S p K hd hempty h.2 true _ (hg xx hx) hxg'.symm,?_⟩ |
| apply body.graph_complete d S p K hd hempty h'.1 y _ (hb xx hx hxg') |
| simpa only [domain_cons_val] using hy.symm |
| · rintro ⟨x,hx,hxg,hy⟩ |
| have hgt := guard.graph_sound d S p K hd true (Fin.cons x env) hxg |
| have hbt := body.graph_sound d S p K hd y (Fin.cons x env) hy |
| simp only [domain_cons_val] at hgt hbt |
| exact ⟨x.val,⟨hx,hgt.symm⟩,hbt.symm⟩ |
| | iterate step => |
| let x : Domain d := ⟨emptyHF,hempty⟩ |
| refine ⟨x,rfl,LoopGraph.complete p K (step.Graph d S p K) |
| (fun y => step.traced S p (Fin.cons y (fun j => (env j).val))) env |
| (fun y => step.traced_self S p _) ?_ (p+1) z x ht hz⟩ |
| intro a b ha hb |
| apply step.graph_complete d S p K hd hempty hzero b (Fin.cons a env) |
| · simpa only [domain_cons_val] using ha |
| · simpa only [domain_cons_val] using hb |
| termination_by sizeOf t |
| decreasing_by all_goals subst_vars; simp_wf <;> omega |
| lemma Formula.graph_complete (d : Set (HF A)) (S : Input A) (p K : ℕ) |
| (hd : ∀ x ∈ d, ∀ y, y ∈ x → y ∈ d) (hempty : emptyHF ∈ d) {n : ℕ} (f : Formula n) (hzero : f.wscCount = 0) |
| (v : Bool) (env : Fin n → Domain d) |
| (ht : AdmissibleTrace d K (f.traced S p (fun j => (env j).val)).2) |
| (hv : v = (f.traced S p (fun j => (env j).val)).1) : f.Graph d S p K v env := by |
| cases f with |
| | equal a b | input r a b => |
| have h := Nat.add_eq_zero_iff.mp hzero |
| have ha := ht.mono Finset.subset_union_left |
| have hb := ht.mono Finset.subset_union_right |
| let x : Domain d := ⟨(a.traced S p (fun j => (env j).val)).1,(ha _ (a.traced_self S p _)).1⟩ |
| let y : Domain d := ⟨(b.traced S p (fun j => (env j).val)).1,(hb _ (b.traced_self S p _)).1⟩ |
| exact ⟨x,y,a.graph_complete d S p K hd hempty h.1 x env ha rfl, |
| b.graph_complete d S p K hd hempty h.2 y env hb rfl,hv⟩ |
| | neg a => exact ⟨_,a.graph_complete d S p K hd hempty hzero _ env ht rfl,hv⟩ |
| | and a b | or a b => |
| have h := Nat.add_eq_zero_iff.mp hzero |
| exact ⟨_,_,a.graph_complete d S p K hd hempty h.1 _ env (ht.mono Finset.subset_union_left) rfl, |
| b.graph_complete d S p K hd hempty h.2 _ env (ht.mono Finset.subset_union_right) rfl,hv⟩ |
| | wsc step choice witness output => simp only [Formula.wscCount] at hzero; omega |
| termination_by sizeOf f |
| decreasing_by all_goals subst_vars; simp_wf <;> omega |
| end |
| |
| end |
| |
| end WitnessedChoice.BGS |
| |
| namespace WitnessedChoice.BGS |
| |
| noncomputable section |
| |
| open Classical WitnessedSeparation WitnessedSeparation.Hereditary WitnessedSeparation.Counting WitnessedSeparation.HFCoding |
| |
| variable {ι R : Type} {D : ι → Type} {S : ∀ i, Counting.Structure R (D i)} {m n : ℕ} |
|
|
| lemma uniform_const (P : Prop) : UniformDefinable S m n (fun _ _ => P) := by |
| by_cases h : P |
| · exact UniformDefinable.falsum.neg.congr (fun _ _ => by simp [h]) |
| · exact UniformDefinable.falsum.congr (fun _ _ => by simp [h]) |
|
|
| lemma uniform_exists_finite {X : Type} [Fintype X] {P : X → ∀ i, (Fin n → D i) → Prop} |
| (h : ∀ x, UniformDefinable S m n (P x)) : |
| UniformDefinable S m n (fun i v => ∃ x, P x i v) := by |
| simpa only [Finset.mem_univ,true_and] using |
| UniformDefinable.exists_finset Finset.univ (fun x _ => h x) |
|
|
| lemma uniform_decide {P : ∀ i, (Fin n → D i) → Prop} |
| (h : UniformDefinable S m n P) (b : Bool) : |
| UniformDefinable S m n (fun i v => b = decide (P i v)) := by |
| cases b |
| · exact h.neg.congr (fun _ _ => by simp) |
| · exact h.congr (fun _ _ => by simp) |
|
|
| lemma uniform_formula_binary |
| {P Q : ∀ i, (Fin (n+1) → D i) → Prop} {T : ∀ i, (Fin 2 → D i) → Prop} |
| (hP : UniformDefinable S m (n+1) P) (hQ : UniformDefinable S m (n+1) Q) |
| (hT : UniformDefinable S m 2 T) (hr : n+1 < m) : |
| UniformDefinable S m n (fun i v => ∃ x y, |
| P i (Fin.cons x v) ∧ Q i (Fin.cons y v) ∧ T i ![x,y]) := by |
| have h1 := hP.reindex (Fin.cons 1 (fun j => j.succ.succ) : Fin (n+1) → Fin (n+2)) |
| have h2 := hQ.reindex (Fin.cons 0 (fun j => j.succ.succ) : Fin (n+1) → Fin (n+2)) |
| have h3 := hT.reindex (![1,0] : Fin 2 → Fin (n+2)) |
| apply (((h1.and (h2.and h3)).ex hr).ex (by omega)).congr |
| intro i v |
| apply exists_congr; intro x |
| apply exists_congr; intro y |
| have h1' : Fin.cons y (Fin.cons x v) ∘ |
| (Fin.cons 1 (fun j => j.succ.succ) : Fin (n+1) → Fin (n+2)) = Fin.cons x v := by |
| funext j; exact Fin.cases rfl (fun _ => rfl) j |
| have h2' : Fin.cons y (Fin.cons x v) ∘ |
| (Fin.cons 0 (fun j => j.succ.succ) : Fin (n+1) → Fin (n+2)) = Fin.cons y v := by |
| funext j; exact Fin.cases rfl (fun _ => rfl) j |
| have h3' : Fin.cons y (Fin.cons x v) ∘ (![1,0] : Fin 2 → Fin (n+2)) = ![x,y] := by |
| funext j; fin_cases j <;> rfl |
| simp only [h1',h2',h3'] |
| |
| variable {A : ι → Type} (d : ∀ i, Set (HF (A i))) |
|
|
| variable (T : ∀ i, Counting.Structure R (Domain (d i))) |
|
|
| variable (hmem : UniformDefinable T m 2 (fun _ v => (v 0).val ∈ (v 1).val)) |
|
|
| variable (hset : UniformDefinable T m 1 (fun _ v => isSet (v 0).val = true)) |
|
|
| include hmem hset in |
| lemma uniform_BGS_comprehension |
| {P : ∀ i, Domain (d i) → (Fin n → Domain (d i)) → Prop} |
| {Q : ∀ i, Bool → (Fin (n+1) → Domain (d i)) → Prop} |
| {B : ∀ i, Domain (d i) → (Fin (n+1) → Domain (d i)) → Prop} |
| (hP : UniformDefinable T m (n+1) (fun i v => P i (v 0) (Fin.tail v))) |
| (hQ : ∀ b, UniformDefinable T m (n+1) (fun i v => Q i b v)) |
| (hB : UniformDefinable T m (n+2) (fun i v => B i (v 0) (Fin.tail v))) |
| (hm : n+4 ≤ m) : UniformDefinable T m (n+1) (fun i v => ∃ r, |
| P i r (Fin.tail v) ∧ |
| (∀ x : Domain (d i), x.val ∈ r.val → ∃ b : Bool, |
| Q i b (Fin.cons x (Fin.tail v)) ∧ |
| (b = true → ∃ y : Domain (d i), B i y (Fin.cons x (Fin.tail v)))) ∧ |
| isSet (v 0).val = true ∧ ∀ y : Domain (d i), y.val ∈ (v 0).val ↔ |
| ∃ x : Domain (d i), x.val ∈ r.val ∧ Q i true (Fin.cons x (Fin.tail v)) ∧ |
| B i y (Fin.cons x (Fin.tail v))) := by |
| have hBtotal := (hB.reindex |
| (Fin.cons 0 (Fin.cons 1 (fun j => j.succ.succ.succ.succ)) : Fin (n+2) → Fin (n+4))).ex (by omega) |
| have htotal := ((hmem.reindex (![0,1] : Fin 2 → Fin (n+3))).imp |
| (uniform_exists_finite (fun b : Bool => |
| ((hQ b).reindex (Fin.cons 0 (fun j => j.succ.succ.succ) : Fin (n+1) → Fin (n+3))).and |
| ((uniform_const (b = true)).imp hBtotal)))).all (by omega) |
| have hguard := (hQ true).reindex |
| (Fin.cons 0 (fun j => j.succ.succ.succ.succ) : Fin (n+1) → Fin (n+4)) |
| have hbody := hB.reindex |
| (Fin.cons 1 (Fin.cons 0 (fun j => j.succ.succ.succ.succ)) : Fin (n+2) → Fin (n+4)) |
| have hrhs := ((hmem.reindex (![0,2] : Fin 2 → Fin (n+4))).and (hguard.and hbody)).ex (by omega) |
| have hext := ((hmem.reindex (![0,2] : Fin 2 → Fin (n+3))).iff hrhs).all (by omega) |
| have hbound := hP.reindex (Fin.cons 0 (fun j => j.succ.succ) : Fin (n+1) → Fin (n+2)) |
| have hset' := hset.reindex (![1] : Fin 1 → Fin (n+2)) |
| apply ((hbound.and (htotal.and (hset'.and hext))).ex (by omega)).congr |
| intro i v |
| simp only [Fin.comp_cons,Fin.cons_zero,Fin.tail_cons,Function.comp_apply] |
| rfl |
|
|
| lemma LoopGraph.uniform (p : ℕ) |
| (step : ∀ i, Domain (d i) → (Fin (n+1) → Domain (d i)) → Prop) |
| (hstep : UniformDefinable T m (n+2) (fun i v => step i (v 0) (Fin.tail v))) |
| (hcut : UniformDefinable T m 1 (fun _ v => (TC (v 0).val).card ≤ p)) |
| (hemp : UniformDefinable T m 1 (fun _ v => (v 0).val = emptyHF)) |
| (hm : n+2 < m) (fuel : ℕ) : UniformDefinable T m (n+2) |
| (fun i v => LoopGraph (d i) p (step i) fuel (v 0) (v 1) (Fin.tail (Fin.tail v))) := by |
| induction fuel with |
| | zero => exact hemp.reindex ![0] |
| | succ fuel ih => |
| have hc := hcut.reindex (![1] : Fin 1 → Fin (n+2)) |
| have hz := hemp.reindex (![0] : Fin 1 → Fin (n+2)) |
| have hs := hstep.reindex (Fin.cons 0 (Fin.cons 2 (fun j => j.succ.succ.succ)) : Fin (n+2) → Fin (n+3)) |
| have hxy : UniformDefinable T m (n+3) (fun _ v => v 2 = v 0) := UniformDefinable.equal 2 0 |
| have hzx : UniformDefinable T m (n+3) (fun _ v => v 1 = v 2) := UniformDefinable.equal 1 2 |
| have hrec := ih.reindex (Fin.cons 1 (Fin.cons 0 (fun j => j.succ.succ.succ)) : Fin (n+2) → Fin (n+3)) |
| have hy := (hs.and ((hxy.and hzx).or (hxy.neg.and hrec))).ex hm |
| apply ((hc.neg.and hz).or (hc.and hy)).congr |
| intro i v |
| have hvc : v ∘ (![1] : Fin 1 → Fin (n+2)) = ![v 1] := by |
| funext j; fin_cases j; rfl |
| have hvz : v ∘ (![0] : Fin 1 → Fin (n+2)) = ![v 0] := by |
| funext j; fin_cases j; rfl |
| have hs' (y : Domain (d i)) : Fin.cons y v ∘ |
| (Fin.cons 0 (Fin.cons 2 (fun j => j.succ.succ.succ)) : Fin (n+2) → Fin (n+3)) = |
| Fin.cons y (Fin.cons (v 1) (Fin.tail (Fin.tail v))) := by |
| funext j; refine Fin.cases rfl (fun j => ?_) j |
| exact Fin.cases rfl (fun _ => rfl) j |
| have hr' (y : Domain (d i)) : Fin.cons y v ∘ |
| (Fin.cons 1 (Fin.cons 0 (fun j => j.succ.succ.succ)) : Fin (n+2) → Fin (n+3)) = |
| Fin.cons (v 0) (Fin.cons y (Fin.tail (Fin.tail v))) := by |
| funext j; refine Fin.cases rfl (fun j => ?_) j |
| exact Fin.cases rfl (fun _ => rfl) j |
| simp only [hvc,hvz,hs',hr',Fin.cons_zero,Fin.tail_cons] |
| simp only [LoopGraph,not_le] |
| rfl |
| |
| end |
| |
| end WitnessedChoice.BGS |
| |
| namespace WitnessedChoice.BGS |
| |
| noncomputable section |
| |
| open Classical WitnessedSeparation WitnessedSeparation.Hereditary WitnessedSeparation.Counting WitnessedSeparation.HFCoding |
| |
| lemma unionHF_eq_operational {A : Type} (x : HF A) : unionHF x = Operational.unionHF x := by |
| unfold unionHF Operational.unionHF |
| congr 1 |
| ext y |
| simp only [Finset.mem_biUnion] |
|
|
| lemma uniqueHF_eq_operational {A : Type} (x : HF A) : uniqueHF x = Operational.uniqueHF x := rfl |
|
|
| lemma cardHF_eq_operational {A : Type} (x : HF A) : cardHF x = Operational.cardinalityHF x := rfl |
|
|
| lemma atomsHF_eq_operational {A : Type} [Fintype A] : |
| ofFinset (Finset.univ.image (atom (A := A))) = (Operational.allAtoms : HF A) := by |
| unfold Operational.allAtoms |
| congr 1 |
| ext y |
| simp only [Finset.mem_image] |
|
|
| mutual |
| def Term.graphWidth : {n : ℕ} → Term n → ℕ |
| | n, .var _ | n, .empty | n, .atoms => n+8 |
| | n, .pair a b => n+8+a.graphWidth+b.graphWidth |
| | n, .union a | n, .unique a | n, .card a => n+8+a.graphWidth |
| | n, .comprehend b r g => n+8+b.graphWidth+r.graphWidth+g.graphWidth |
| | n, .iterate step => n+8+step.graphWidth |
| def Formula.graphWidth : {n : ℕ} → Formula n → ℕ |
| | n, .equal a b | n, .input _ a b => n+8+a.graphWidth+b.graphWidth |
| | n, .neg a => n+8+a.graphWidth |
| | n, .and a b | n, .or a b => n+8+a.graphWidth+b.graphWidth |
| | n, .wsc _ _ _ _ => n+8 |
| end |
|
|
| variable {ι R : Type} {A : ι → Type} [∀ i, Fintype (A i)] |
|
|
| variable (d : ∀ i, Set (HF (A i))) (T : ∀ i, Counting.Structure R (Domain (d i))) {m : ℕ} |
|
|
| variable (hd : ∀ i, ∀ x ∈ d i, ∀ y, y ∈ x → y ∈ d i) |
|
|
| variable (hp : ∀ i k, ordinal (A := A i) k ∈ d i) |
|
|
| variable (ha : ∀ i a, atom a ∈ d i) |
|
|
| variable (hmem : UniformDefinable T m 2 (fun _ v => (v 0).val ∈ (v 1).val)) |
|
|
| variable (hset : UniformDefinable T m 1 (fun _ v => isSet (v 0).val = true)) |
|
|
| variable (S : ∀ i, Input (A i)) |
|
|
| variable (hinput : ∀ r, UniformDefinable T m 2 |
| (fun i v => Operational.inputRelation (S i).rel r (v 0).val (v 1).val)) |
|
|
| mutual |
| lemma Term.uniform_graph (d : ∀ i, Set (HF (A i))) (T : ∀ i, Counting.Structure R (Domain (d i))) |
| (hd : ∀ i, ∀ x ∈ d i, ∀ y, y ∈ x → y ∈ d i) |
| (hp : ∀ i k, ordinal (A := A i) k ∈ d i) |
| (ha : ∀ i a, atom a ∈ d i) |
| (hmem : UniformDefinable T m 2 (fun _ v => (v 0).val ∈ (v 1).val)) |
| (hset : UniformDefinable T m 1 (fun _ v => isSet (v 0).val = true)) |
| (S : ∀ i, Input (A i)) |
| (hinput : ∀ r, UniformDefinable T m 2 |
| (fun i v => Operational.inputRelation (S i).rel r (v 0).val (v 1).val)) (p K : ℕ) {n : ℕ} (t : Term n) (hm : t.graphWidth ≤ m) : |
| UniformDefinable T m (n+1) (fun i v => t.Graph (d i) (S i) p K (v 0) (Fin.tail v)) := by |
| cases t with |
| | var j => exact UniformDefinable.equal 0 j.succ |
| | empty => |
| simp only [Term.graphWidth] at hm |
| exact (HFCoding.uniform_ordinal T hmem hset (by omega) hd hp 0).reindex ![0] |
| | atoms => |
| simp only [Term.graphWidth] at hm |
| apply ((Operational.uniform_atoms d T hd ha hmem hset (by omega)).reindex ![0]).congr |
| intro i v |
| simp only [Term.Graph,atomsHF_eq_operational,Function.comp_apply] |
| rfl |
| | pair a b => |
| simp only [Term.graphWidth] at hm |
| exact UniformDefinable.compose_binary |
| (a.uniform_graph d T hd hp ha hmem hset S hinput p K (by omega)) |
| (b.uniform_graph d T hd hp ha hmem hset S hinput p K (by omega)) |
| (Operational.uniform_double_value d T hd hmem hset (by omega)) (by omega) |
| | union a => |
| simp only [Term.graphWidth] at hm |
| have hh := UniformDefinable.compose_unary |
| (a.uniform_graph d T hd hp ha hmem hset S hinput p K (by omega)) |
| (Operational.uniform_union d T hd hmem hset (by omega)) (by omega : n+1 < m) |
| apply hh.congr |
| intro i v |
| simp only [Term.Graph,unionHF_eq_operational,Fin.cons_zero,Fin.tail_cons] |
| rfl |
| | unique a => |
| simp only [Term.graphWidth] at hm |
| exact UniformDefinable.compose_unary |
| (a.uniform_graph d T hd hp ha hmem hset S hinput p K (by omega)) |
| (Operational.uniform_unique d T hd hp hmem hset (by omega)) (by omega) |
| | card a => |
| simp only [Term.graphWidth] at hm |
| exact UniformDefinable.compose_unary |
| (a.uniform_graph d T hd hp ha hmem hset S hinput p K (by omega)) |
| (Operational.uniform_card d T hd hp hmem hset (by omega) K) (by omega) |
| | comprehend body range guard => |
| simp only [Term.graphWidth] at hm |
| exact uniform_BGS_comprehension d T hmem hset |
| (range.uniform_graph d T hd hp ha hmem hset S hinput p K (by omega)) |
| (fun b => guard.uniform_graph d T hd hp ha hmem hset S hinput p K b (by omega)) |
| (body.uniform_graph d T hd hp ha hmem hset S hinput p K (by omega)) (by omega) |
| | iterate step => |
| simp only [Term.graphWidth] at hm |
| have hs := step.uniform_graph d T hd hp ha hmem hset S hinput p K (by omega) |
| have hc := uniform_TC_bound d T hd hmem (by omega) p |
| have he : UniformDefinable T m 1 (fun _ v => (v 0).val = emptyHF) := |
| HFCoding.uniform_ordinal T hmem hset (by omega) hd hp 0 |
| have hl := (LoopGraph.uniform d T p (fun i => step.Graph (d i) (S i) p K) |
| hs hc he (by omega : n+2 < m) (p+1)).reindex |
| (Fin.cons 1 (Fin.cons 0 (fun j => j.succ.succ)) : Fin (n+2) → Fin (n+2)) |
| apply (((he.reindex (![0] : Fin 1 → Fin (n+2))).and hl).ex (by omega)).congr |
| intro i v |
| simp only [Term.Graph,Fin.comp_cons,Fin.cons_zero,Fin.tail_cons,Function.comp_apply] |
| rfl |
| termination_by sizeOf t |
| decreasing_by all_goals subst_vars; simp_wf <;> omega |
| lemma Formula.uniform_graph (d : ∀ i, Set (HF (A i))) (T : ∀ i, Counting.Structure R (Domain (d i))) |
| (hd : ∀ i, ∀ x ∈ d i, ∀ y, y ∈ x → y ∈ d i) |
| (hp : ∀ i k, ordinal (A := A i) k ∈ d i) |
| (ha : ∀ i a, atom a ∈ d i) |
| (hmem : UniformDefinable T m 2 (fun _ v => (v 0).val ∈ (v 1).val)) |
| (hset : UniformDefinable T m 1 (fun _ v => isSet (v 0).val = true)) |
| (S : ∀ i, Input (A i)) |
| (hinput : ∀ r, UniformDefinable T m 2 |
| (fun i v => Operational.inputRelation (S i).rel r (v 0).val (v 1).val)) (p K : ℕ) {n : ℕ} (f : Formula n) (b : Bool) |
| (hm : f.graphWidth ≤ m) : |
| UniformDefinable T m n (fun i v => f.Graph (d i) (S i) p K b v) := by |
| cases f with |
| | equal a c => |
| simp only [Formula.graphWidth] at hm |
| have he : UniformDefinable T m 2 (fun _ v => (v 0).val = (v 1).val) := |
| (UniformDefinable.equal 0 1).congr (fun _ _ => Subtype.ext_iff) |
| apply (uniform_formula_binary |
| (a.uniform_graph d T hd hp ha hmem hset S hinput p K (by omega)) |
| (c.uniform_graph d T hd hp ha hmem hset S hinput p K (by omega)) |
| (uniform_decide he b) (by omega : n+1 < m)).congr |
| intro i v |
| simp only [Formula.Graph,Fin.cons_zero,Fin.tail_cons] |
| apply exists_congr; intro x |
| apply exists_congr; intro y |
| simp only [Matrix.cons_val_zero,Matrix.cons_val_one] |
| apply and_congr_right; intro _ |
| apply and_congr_right; intro _ |
| apply Iff.of_eq |
| apply congrArg (fun z : Bool => b = z) |
| exact decide_eq_decide.mpr Iff.rfl |
| | input r a c => |
| simp only [Formula.graphWidth] at hm |
| exact uniform_formula_binary |
| (a.uniform_graph d T hd hp ha hmem hset S hinput p K (by omega)) |
| (c.uniform_graph d T hd hp ha hmem hset S hinput p K (by omega)) |
| (uniform_decide (hinput r) b) (by omega) |
| | neg a => |
| simp only [Formula.graphWidth] at hm |
| exact uniform_exists_finite (fun c : Bool => |
| (a.uniform_graph d T hd hp ha hmem hset S hinput p K c (by omega)).and |
| (uniform_const (b = !c))) |
| | and a c => |
| simp only [Formula.graphWidth] at hm |
| exact uniform_exists_finite (fun x : Bool => uniform_exists_finite (fun y : Bool => |
| (a.uniform_graph d T hd hp ha hmem hset S hinput p K x (by omega)).and |
| ((c.uniform_graph d T hd hp ha hmem hset S hinput p K y (by omega)).and |
| (uniform_const (b = (x && y)))))) |
| | or a c => |
| simp only [Formula.graphWidth] at hm |
| exact uniform_exists_finite (fun x : Bool => uniform_exists_finite (fun y : Bool => |
| (a.uniform_graph d T hd hp ha hmem hset S hinput p K x (by omega)).and |
| ((c.uniform_graph d T hd hp ha hmem hset S hinput p K y (by omega)).and |
| (uniform_const (b = (x || y)))))) |
| | wsc step choice witness output => exact UniformDefinable.falsum |
| termination_by sizeOf f |
| decreasing_by all_goals subst_vars; simp_wf <;> omega |
| end |
| |
| end |
| |
| end WitnessedChoice.BGS |
| |
| end |
| |
| section |
| |
| namespace WitnessedChoice.BGS |
| |
| noncomputable section |
| |
| open Classical WitnessedSeparation WitnessedSeparation.Hereditary Finset |
| |
| open WitnessedSeparation.Operational (lift lift_elements lift_ofFinset lift_empty lift_double) |
| |
| variable {A B : Type} |
|
|
| lemma lift_emptyHF (e : A ≃ B) : lift e emptyHF = emptyHF := Operational.lift_empty e |
|
|
| lemma lift_unionHF (e : A ≃ B) (x : HF A) : lift e (unionHF x) = unionHF (lift e x) := by |
| simpa only [unionHF_eq_operational] using Operational.lift_union e x |
|
|
| lemma lift_uniqueHF (e : A ≃ B) (x : HF A) : lift e (uniqueHF x) = uniqueHF (lift e x) := |
| Operational.lift_unique e x |
|
|
| lemma lift_cardHF (e : A ≃ B) (x : HF A) : lift e (cardHF x) = cardHF (lift e x) := |
| Operational.lift_card e x |
|
|
| lemma lift_atomsHF [Fintype A] [Fintype B] (e : A ≃ B) : |
| lift e (ofFinset (univ.image (atom (A := A)))) = ofFinset (univ.image atom) := by |
| simpa only [atomsHF_eq_operational] using Operational.lift_allAtoms e |
|
|
| lemma lift_inputHF (e : A ≃ B) (S : Input A) (T : Input B) |
| (h : ∀ r a b, T.rel r (e a) (e b) = S.rel r a b) (r : Symbol) (x y : HF A) : |
| inputHF T r (lift e x) (lift e y) = inputHF S r x y := by |
| apply Bool.eq_iff_iff.mpr |
| simpa only [inputHF,decide_eq_true_eq,Operational.inputRelation] using |
| Operational.lift_input e S.rel T.rel h r x y |
|
|
| variable [Fintype A] [Fintype B] |
|
|
| omit [Fintype A] [Fintype B] in |
| lemma lift_closureHF (e : A ≃ B) (x : HF A) : |
| closure (lift e x) = (closure x).image (lift e) := by |
| ext y |
| have hh := congrArg (fun z : Finset (HF B) => y ∈ z) (Operational.lift_closure e x) |
| simpa only [mem_image] using Iff.of_eq hh |
|
|
| omit [Fintype A] [Fintype B] in |
| lemma lift_TC (e : A ≃ B) (x : HF A) : TC (lift e x) = (TC x).image (lift e) := by |
| simp only [TC,lift_elements,biUnion_image,image_biUnion,lift_closureHF] |
|
|
| omit [Fintype A] [Fintype B] in |
| lemma lift_TC_card (e : A ≃ B) (x : HF A) : (TC (lift e x)).card = (TC x).card := by |
| rw [lift_TC,card_image_of_injective _ (lift e).injective] |
|
|
| omit [Fintype A] [Fintype B] in |
| lemma lift_cons (e : A ≃ B) {n : ℕ} (env : Fin n → HF A) (x : HF A) : |
| (fun j => lift e ((Fin.cons x env : Fin (n+1) → HF A) j)) = |
| Fin.cons (lift e x) (fun j => lift e (env j)) := by |
| funext j; exact Fin.cases rfl (fun _ => rfl) j |
| |
| omit [Fintype A] [Fintype B] in |
| lemma tracedLoop_transport (e : A ≃ B) (p : ℕ) |
| (a : HF A → Traced A (HF A)) (b : HF B → Traced B (HF B)) |
| (h : ∀ x, b (lift e x) = (lift e (a x).1,(a x).2.image (lift e))) |
| (fuel : ℕ) (x : HF A) : |
| tracedLoop p b fuel (lift e x) = |
| (lift e (tracedLoop p a fuel x).1,(tracedLoop p a fuel x).2.image (lift e)) := by |
| induction fuel generalizing x with |
| | zero => simp only [tracedLoop,lift_emptyHF,closure_emptyHF,image_singleton] |
| | succ fuel ih => |
| simp only [tracedLoop,lift_TC_card,h,Equiv.apply_eq_iff_eq] |
| split_ifs with hb he |
| · rfl |
| · simp only [ih,image_union] |
| · simp only [lift_emptyHF,closure_emptyHF,image_singleton] |
|
|
| omit [Fintype A] [Fintype B] in |
| lemma selected_transport (e : A ≃ B) (r : HF A) |
| (a : HF A → Bool) (b : HF B → Bool) (h : ∀ x, b (lift e x) = a x) : |
| ((elements (lift e r)).filter (fun y => b y = true)) = |
| ((elements r).filter (fun x => a x = true)).image (lift e) := by |
| rw [lift_elements] |
| ext y |
| simp only [mem_filter,mem_image] |
| constructor |
| · rintro ⟨⟨x,hx,rfl⟩,hy⟩ |
| exact ⟨x,⟨hx,by rwa [h] at hy⟩,rfl⟩ |
| · rintro ⟨x,⟨hx,hy⟩,rfl⟩ |
| exact ⟨⟨x,hx,rfl⟩,by rwa [h]⟩ |
|
|
| mutual |
| theorem Term.traced_transport (e : A ≃ B) (S : Input A) (T : Input B) |
| (h : ∀ r a b, T.rel r (e a) (e b) = S.rel r a b) (p : ℕ) |
| {n : ℕ} (t : Term n) (env : Fin n → HF A) : |
| t.traced T p (fun j => lift e (env j)) = |
| (lift e (t.traced S p env).1,(t.traced S p env).2.image (lift e)) := by |
| cases t with |
| | var j => exact Prod.ext rfl (lift_closureHF e _) |
| | empty => simp only [Term.traced,lift_emptyHF,closure_emptyHF,image_singleton] |
| | atoms => simp only [Term.traced,← lift_atomsHF e,lift_closureHF] |
| | pair a b => |
| simp only [Term.traced,a.traced_transport e S T h p env,b.traced_transport e S T h p env, |
| image_insert,image_union,lift_double] |
| | union a => |
| simp only [Term.traced,a.traced_transport e S T h p env,image_insert,lift_unionHF] |
| | unique a => |
| simp only [Term.traced,a.traced_transport e S T h p env,image_insert,lift_uniqueHF] |
| | card a => |
| simp only [Term.traced,a.traced_transport e S T h p env,image_union,← lift_cardHF,lift_closureHF] |
| | comprehend body range guard => |
| have hr := range.traced_transport e S T h p env |
| have hg (x : HF A) := guard.traced_transport e S T h p (Fin.cons x env) |
| have hb (x : HF A) := body.traced_transport e S T h p (Fin.cons x env) |
| simp only [lift_cons] at hg hb |
| have hs := selected_transport e (range.traced S p env).1 |
| (fun x => (guard.traced S p (Fin.cons x env)).1) |
| (fun x => (guard.traced T p (Fin.cons x (fun j => lift e (env j)))).1) |
| (fun x => congrArg Prod.fst (hg x)) |
| simp only [Term.traced,hr] |
| rw [hs] |
| simp only [image_image,Function.comp_def,hb,lift_ofFinset, |
| lift_elements,biUnion_image,image_insert,image_union,image_biUnion,hg] |
| congr 2 <;> first | rfl | (apply congrArg ofFinset; ext z; simp only [mem_image]) | (ext z; simp only [mem_image]) |
| | iterate step => |
| have hh (x : HF A) := step.traced_transport e S T h p (Fin.cons x env) |
| simp only [lift_cons] at hh |
| have hx := tracedLoop_transport e p |
| (fun x => step.traced S p (Fin.cons x env)) |
| (fun x => step.traced T p (Fin.cons x (fun j => lift e (env j)))) hh (p+1) emptyHF |
| simpa only [Term.traced,lift_emptyHF] using hx |
| theorem Formula.traced_transport (e : A ≃ B) (S : Input A) (T : Input B) |
| (h : ∀ r a b, T.rel r (e a) (e b) = S.rel r a b) (p : ℕ) |
| {n : ℕ} (f : Formula n) (env : Fin n → HF A) : |
| f.traced T p (fun j => lift e (env j)) = |
| ((f.traced S p env).1,(f.traced S p env).2.image (lift e)) := by |
| cases f with |
| | equal a b => |
| simp only [Formula.traced,a.traced_transport e S T h p env,b.traced_transport e S T h p env, |
| Equiv.apply_eq_iff_eq,image_union] |
| | input r a b => |
| simp only [Formula.traced,a.traced_transport e S T h p env,b.traced_transport e S T h p env, |
| lift_inputHF e S T h,image_union] |
| | neg a => simp only [Formula.traced,a.traced_transport e S T h p env] |
| | and a b | or a b => |
| simp only [Formula.traced,a.traced_transport e S T h p env,b.traced_transport e S T h p env,image_union] |
| | wsc step choice witness output => simp only [Formula.traced,image_empty] |
| end |
|
|
| end |
|
|
| end WitnessedChoice.BGS |
|
|
| namespace WitnessedChoice.BGS |
|
|
| noncomputable section |
|
|
| open Classical WitnessedSeparation |
|
|
| lemma realPolynomial_majorant (p : Polynomial ℝ) : |
| ∃ q : Polynomial ℕ, ∀ n : ℕ, p.eval (n : ℝ) ≤ ((q.eval n : ℕ) : ℝ) := by |
| induction p using Polynomial.induction_on' with |
| | add a b ha hb => |
| obtain ⟨q,hq⟩ := ha |
| obtain ⟨r,hr⟩ := hb |
| refine ⟨q+r,fun n => ?_⟩ |
| simpa only [Polynomial.eval_add,Nat.cast_add] using add_le_add (hq n) (hr n) |
| | monomial k a => |
| refine ⟨Polynomial.monomial k ⌈|a|⌉₊,fun n => ?_⟩ |
| simp only [Polynomial.eval_monomial,Nat.cast_mul,Nat.cast_pow] |
| apply mul_le_mul_of_nonneg_right ((le_abs_self a).trans (Nat.le_ceil _)) |
| positivity |
|
|
| lemma resource_majorant (p : Polynomial ℝ) : |
| ∃ q : Polynomial ℕ, ∀ n : ℕ, resource p n ≤ q.eval n := by |
| obtain ⟨q,hq⟩ := realPolynomial_majorant p |
| refine ⟨q,fun n => ?_⟩ |
| have hh := Nat.floor_mono (hq n) |
| simpa only [resource,Nat.floor_natCast] using hh |
|
|
| end |
|
|
| end WitnessedChoice.BGS |
|
|
| namespace WitnessedChoice.BGS |
|
|
| noncomputable section |
|
|
| open Classical WitnessedSeparation WitnessedSeparation.Hereditary WitnessedSeparation.HFCoding |
|
|
| open WitnessedSeparation.Grid WitnessedSeparation.Counting Finset |
|
|
| open WitnessedSeparation.Operational (lift) |
|
|
| variable {n : ℕ} |
|
|
| lemma Formula.grid_trace_invariant (f : Formula 0) (b : Vertex n → Grid.Scalar) |
| (p : ℕ) : ∀ g : BoxGroup n, ∀ x ∈ (f.traced (atomInput b) p Fin.elim0).2, |
| g • x ∈ (f.traced (atomInput b) p Fin.elim0).2 := by |
| intro g x hx |
| have ht := f.traced_transport (actionIso (b := b) g).toEquiv (atomInput b) (atomInput b) |
| (fun r a c => (actionIso g).rel_eq r a c) p Fin.elim0 |
| have he : (fun j : Fin 0 => lift (actionIso (b := b) g).toEquiv (Fin.elim0 j)) = Fin.elim0 := |
| funext (fun j => Fin.elim0 j) |
| rw [he] at ht |
| have hm : g • x ∈ (f.traced (atomInput b) p Fin.elim0).2.image |
| (lift (actionIso (b := b) g).toEquiv) := mem_image.mpr ⟨x,hx,rfl⟩ |
| exact (congrArg (fun z => g • x ∈ z.2) ht).mpr hm |
|
|
| lemma Formula.grid_trace_supported (f : Formula 0) (b : Vertex n → Grid.Scalar) |
| (hn : 1 ≤ n) (p K N q : ℕ) (hN : 0 < N) |
| (hb : (f.traced (atomInput b) p Fin.elim0).2.card ≤ K) (hK : K ≤ N^q) : |
| ∀ x ∈ (f.traced (atomInput b) p Fin.elim0).2, |
| HereditarilySupported (G := CentralGroup n) |
| ⌈2*(n+1:ℝ)*((q:ℝ)*Real.logb 3 N)^2⌉₊ x := by |
| apply invariant_family_hereditarily_supported hn _ (f.grid_trace_invariant b p) |
| (fun x hx y hy => f.traced_closed (atomInput b) p Fin.elim0 x hx |
| (closure_member_subset hy (mem_closure_self y))) N hN (q:ℝ) (by positivity) |
| rw [Real.rpow_natCast] |
| exact_mod_cast hb.trans hK |
|
|
| lemma Formula.grid_traced_agrees (f : Formula 0) (hf : f.wscCount = 0) |
| {m M N : ℕ} (vstar : Vertex n) (hn : 1 ≤ n) (p K q : ℕ) |
| (hN : 0 < N) (hK : K ≤ N^q) |
| (hb : ∀ i : Bool, (f.traced (atomInput (twoCharges vstar i)) p Fin.elim0).2.card ≤ K) |
| (hm : f.graphWidth ≤ m) (hmpos : 0 < m) |
| (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) : |
| (f.traced (atomInput (twoCharges vstar false)) p Fin.elim0).1 = |
| (f.traced (atomInput (twoCharges vstar true)) p Fin.elim0).1 := by |
| let s := ⌈2*(n+1:ℝ)*((q:ℝ)*Real.logb 3 N)^2⌉₊ |
| let D := programDomain (twoCharges vstar) (s := s) |
| let C := programHF (twoCharges vstar) (s := s) |
| have ht (i : Bool) : AdmissibleTrace (D i) K |
| (f.traced (atomInput (twoCharges vstar i)) p Fin.elim0).2 := by |
| intro x hx |
| refine ⟨f.grid_trace_supported (twoCharges vstar i) hn p K N q hN (hb i) hK x hx,?_⟩ |
| exact (card_le_card ((elements_subset_closure x).trans |
| (f.traced_closed (atomInput (twoCharges vstar i)) p Fin.elim0 x hx))).trans (hb i) |
| have hu := f.uniform_graph D C (program_domain_transitive (twoCharges vstar)) |
| (program_pure (twoCharges vstar) hn) (program_atom_mem (twoCharges vstar) hs) |
| (program_mem_uniform (twoCharges vstar)) (program_set_uniform (twoCharges vstar)) |
| (fun i => atomInput (twoCharges vstar i)) (op_input_uniform (twoCharges vstar)) p K true hm |
| have he : UniformDefinable C m 0 (fun i _ => |
| (f.traced (atomInput (twoCharges vstar i)) p Fin.elim0).1 = true) := by |
| apply hu.congr |
| intro i env |
| have he : (fun j : Fin 0 => (env j).val) = Fin.elim0 := funext (fun j => Fin.elim0 j) |
| constructor |
| · intro hg |
| have hh := f.graph_sound (D i) (atomInput (twoCharges vstar i)) p K |
| (program_domain_transitive (twoCharges vstar) i) true env hg |
| simpa only [he] using hh.symm |
| · intro hg |
| apply f.graph_complete (D i) (atomInput (twoCharges vstar i)) p K |
| (program_domain_transitive (twoCharges vstar) i) |
| (program_pure (twoCharges vstar) hn i 0) hf true env |
| · simpa only [he] using ht i |
| · simpa only [he] using hg.symm |
| obtain ⟨φ,hφ,hφsem⟩ := he (Fin.elim0 : Fin 0 → Fin m) |
| have hfree : φ.free = ∅ := subset_empty.mp (by simpa using hφ) |
| let v : Fin m → Domain (D false) := fun _ => ⟨ordinal 0,program_pure (twoCharges vstar) hn false 0⟩ |
| let w : Fin m → Domain (D true) := fun _ => ⟨ordinal 0,program_pure (twoCharges vstar) hn true 0⟩ |
| let := atom_nonempty hn (0 : Vertex n → Grid.Scalar) |
| let := atom_nonempty hn (Pi.single vstar 1) |
| apply Bool.eq_iff_iff.mpr |
| exact (hφsem false v).symm.trans ((grid_hf_transfer hn hs hmpos vstar |
| hwidth hhom hgiant φ hfree v w).trans (hφsem true w)) |
|
|
| end |
|
|
| end WitnessedChoice.BGS |
|
|
| namespace WitnessedChoice.BGS |
|
|
| noncomputable section |
|
|
| open Classical WitnessedSeparation WitnessedSeparation.Hereditary |
|
|
| open WitnessedSeparation.Grid WitnessedSeparation.Quantitative |
|
|
| def gridInput {n : ℕ} (b : Vertex n → Grid.Scalar) : FiniteInput := |
| ⟨Atom b,inferInstance,atomInput b⟩ |
|
|
| theorem Sentence.agrees_on_some_grid_pair (ψ : Sentence) (hψ : ψ.isCPT) : |
| ∃ n : ℕ, 1 ≤ n ∧ ∀ vstar : Vertex n, |
| ψ.eval (gridInput (0 : Vertex n → Grid.Scalar)) = |
| ψ.eval (gridInput (Pi.single vstar 1)) := by |
| obtain ⟨r,hr⟩ := resource_majorant ψ.polynomial |
| let Q : Polynomial ℕ := ψ.formula.traceBound.comp (Polynomial.X+r+1) |
| obtain ⟨c,d,hcd⟩ := PolynomialCost.eval_bound Q |
| let q := timeExponent c d |
| let m := ψ.formula.graphWidth+1 |
| obtain ⟨n,hn,hnum⟩ := exists_numeric_box q (by |
| have h := timeExponent_ge_two c d; omega) m |
| refine ⟨n,hn,fun vstar => ?_⟩ |
| let N := atomSizeConstant*(n+1)^3 |
| let p := resource ψ.polynomial (Fintype.card (Atom (0 : Vertex n → Grid.Scalar))) |
| let K := N^q |
| have hN : 2 ≤ N := hnum.1 |
| have hc : Fintype.card (Atom (0 : Vertex n → Grid.Scalar)) = |
| Fintype.card (Atom (Pi.single vstar 1)) := atom_card_independent hn _ _ |
| have hinput (i : Bool) : Fintype.card (Atom (twoCharges vstar i)) ≤ N := |
| (atom_card_bounds hn _).2 |
| have hres (i : Bool) : resource ψ.polynomial |
| (Fintype.card (Atom (twoCharges vstar i))) = p := by |
| cases i |
| · rfl |
| · exact congrArg (resource ψ.polynomial) hc.symm |
| have hp : p ≤ r.eval N := (hr _).trans (PolynomialCost.eval_mono r (hinput false)) |
| have hb (i : Bool) : (ψ.formula.traced (atomInput (twoCharges vstar i)) p Fin.elim0).2.card ≤ K := by |
| calc |
| _ ≤ ψ.formula.traceBound.eval (N+r.eval N+1) := |
| ψ.formula.traced_card_le _ p Fin.elim0 _ (by |
| simp only [tracePotential,Fin.sum_univ_zero,Nat.add_zero] |
| have hi := hinput i |
| omega) |
| _ = Q.eval N := by simp only [Q,Polynomial.eval_comp,Polynomial.eval_add, |
| Polynomial.eval_X,Polynomial.eval_one] |
| _ ≤ c*(N+1)^d := hcd N |
| _ ≤ K := (polynomial_bounds c d N hN).2.2.1 |
| have hh := ψ.formula.grid_traced_agrees hψ (m := m) vstar hn p K q |
| (by omega : 0 < N) (le_refl K) hb (by omega) (by omega) |
| hnum.2.1 hnum.2.2.1 (by simpa only [N,Nat.cast_mul] using hnum.2.2.2.1) hnum.2.2.2.2 |
| dsimp only [Sentence.eval,gridInput] |
| rw [ψ.formula.eval_traced _ _ hψ,ψ.formula.eval_traced _ _ hψ] |
| change some (ψ.formula.traced (atomInput (0 : Vertex n → Grid.Scalar)) p Fin.elim0).1 = _ |
| rw [← hc] |
| exact congrArg some hh |
|
|
| end |
|
|
| end WitnessedChoice.BGS |
|
|
| end |
|
|
| section |
|
|
| namespace WitnessedChoice |
|
|
| noncomputable section |
|
|
| open Classical WitnessedSeparation WitnessedSeparation.Hereditary |
|
|
| variable {A : Type} [Fintype A] |
|
|
| def fullAut (S : Input A) : Subgroup (Equiv.Perm A) where |
| carrier := {g | ∀ r a b, S.rel r (g a) (g b) = S.rel r a b} |
| one_mem' := by intro r a b; rfl |
| mul_mem' := by |
| intro g h hg hh r a b |
| exact (hg r (h a) (h b)).trans (hh r a b) |
| inv_mem' := by |
| intro g hg r a b |
| symm |
| simpa using hg r (g⁻¹ a) (g⁻¹ b) |
|
|
| def paramAut (S : Input A) (α : HF A) : Subgroup (Equiv.Perm A) := |
| fullAut S ⊓ MulAction.stabilizer (Equiv.Perm A) α |
|
|
| def stateCode (x : Finset A) : HF A := ofFinset (x.image atom) |
|
|
| def choiceCode : Option A → HF A |
| | none => ordinal 0 |
| | some a => atom a |
|
|
| structure Selection (A : Type) where |
| candidates : Finset A → Finset A |
| witnesses : Finset A → Finset (Equiv.Perm A) |
|
|
| namespace Selection |
|
|
| variable (P : Selection A) |
|
|
| def TransitiveAt (x : Finset A) : Prop := |
| ∀ a ∈ P.candidates x, ∀ b ∈ P.candidates x, |
| ∃ g ∈ P.witnesses x, g a = b |
|
|
| def choices (x : Finset A) : Finset (Option A) := |
| if (P.candidates x).Nonempty ∧ P.TransitiveAt x then |
| (P.candidates x).image some |
| else {none} |
|
|
| def advance (x : Finset A) : Option A → Finset A |
| | none => x |
| | some a => insert a x |
|
|
| def Prefix (b : ℕ → Finset A) (c : ℕ → Option A) (k : ℕ) : Prop := |
| b 0 = ∅ ∧ ∀ i < k, c i ∈ P.choices (b i) ∧ b (i+1) = advance (b i) (c i) |
|
|
| def FirstStabilization (b : ℕ → Finset A) (c : ℕ → Option A) (t : ℕ) : Prop := |
| P.Prefix b c (t+1) ∧ (∀ i < t, b i ≠ b (i+1)) ∧ b t = b (t+1) |
|
|
| def witnessAt (_terminal intermediate : Finset A) : Finset (Equiv.Perm A) := |
| P.witnesses intermediate |
|
|
| def HistoryAut (S : Input A) (α : HF A) (b : ℕ → Finset A) (i : ℕ) |
| (g : Equiv.Perm A) : Prop := |
| g ∈ paramAut S α ∧ ∀ j ≤ i, g • stateCode (b j) = stateCode (b j) |
|
|
| def WitnessedAt (S : Input A) (α : HF A) (b : ℕ → Finset A) |
| (terminal : Finset A) (i : ℕ) : Prop := |
| (P.choices (b i)).Nonempty ∧ |
| (∀ g ∈ P.witnessAt terminal (b i), HistoryAut S α b i g) ∧ |
| ∀ u ∈ P.choices (b i), ∀ v ∈ P.choices (b i), |
| ∃ g ∈ P.witnessAt terminal (b i), g • choiceCode u = choiceCode v |
|
|
| def Filtered (S : Input A) (α : HF A) : Prop := |
| (∀ x, (1 : Equiv.Perm A) ∈ P.witnesses x) ∧ |
| (∀ x g, g ∈ P.witnesses x → g ∈ paramAut S α) ∧ |
| (∀ x g, g ∈ P.witnesses x → ∀ a ∈ x, g a = a) |
|
|
| def Fresh : Prop := ∀ x a, a ∈ P.candidates x → a ∉ x |
|
|
| def Equivariant (S : Input A) (α : HF A) : Prop := |
| ∀ g ∈ paramAut S α, ∀ x, |
| P.candidates (x.image g) = (P.candidates x).image g ∧ |
| P.witnesses (x.image g) = (P.witnesses x).image (fun h => g * h * g⁻¹) |
|
|
| end Selection |
|
|
| end |
|
|
| end WitnessedChoice |
|
|
| end |
|
|
| end OAI |
|
|
