| import OAI.Computability.WitnessedChoice.CumulativeEvaluation |
|
|
| namespace OAI |
|
|
| section |
|
|
| namespace WitnessedChoice.BGS |
|
|
| noncomputable section |
|
|
| open Classical WitnessedSeparation WitnessedSeparation.Hereditary WitnessedSeparation.Counting WitnessedSeparation.HFCoding |
|
|
| local instance {A : Type*} : DecidableEq (HF A) := Classical.decEq _ |
|
|
| lemma TC_eq_familyClosure {A : Type} (x : HF A) : TC x = familyClosure (elements x) := by |
| ext y |
| simp only [TC,familyClosure,Finset.mem_biUnion] |
|
|
| lemma descendants_TC_subset {A : Type} (x : HF A) (k : ℕ) : |
| descendants (elements x) k ⊆ TC x := by |
| rw [TC_eq_familyClosure] |
| exact descendants_subset _ _ |
|
|
| lemma descendants_TC_bound {A : Type} (x : HF A) (p : ℕ) : |
| (TC x).card ≤ p ↔ (descendants (elements x) (p+1)).card ≤ p := by |
| constructor |
| · exact fun h => (Finset.card_le_card (descendants_TC_subset x _)).trans h |
| · intro h |
| by_cases he : descendants (elements x) (p+1) = TC x |
| · rwa [he] at h |
| · have he' : descendants (elements x) (p+1) ≠ familyClosure (elements x) := by |
| simpa only [TC_eq_familyClosure] using he |
| have hh := descendants_card_lower (elements x) (p+1) he' |
| omega |
|
|
| lemma TC_closed {A : Type} (x : HF A) {y : HF A} (hy : y ∈ TC x) |
| {z : HF A} (hz : z ∈ y) : z ∈ TC x := by |
| rw [TC_eq_familyClosure] at hy ⊢ |
| exact familyClosure_transitive hy hz |
|
|
| lemma TC_in_domain {A : Type} (d : Set (HF A)) |
| (hd : ∀ x ∈ d, ∀ y, y ∈ x → y ∈ d) {x : HF A} (hx : x ∈ d) : |
| ∀ y ∈ TC x, y ∈ d := by |
| intro y hy |
| rw [TC_eq_familyClosure] at hy |
| obtain ⟨z,hz,hyz⟩ := mem_familyClosure.mp hy |
| have hz' : z ∈ d := hd x hx z hz |
| have hr := (mem_closure_iff _ _).mp hyz |
| clear hx hz hyz |
| induction hr with |
| | refl => exact hz' |
| | @tail u v huv hvz ih => exact ih (hd _ hz' _ hvz) |
|
|
| variable {ι R : Type} {A : ι → Type} |
|
|
| variable (d : ∀ i, Set (HF (A i))) |
|
|
| variable (S : ∀ i, WitnessedSeparation.Counting.Structure R (Domain (d i))) {m : ℕ} |
|
|
| variable (hd : ∀ i, ∀ x ∈ d i, ∀ y, y ∈ x → y ∈ d i) |
|
|
| variable (hmem : UniformDefinable S m 2 (fun _ v => (v 0).val ∈ (v 1).val)) |
|
|
| variable (hm : 3 ≤ m) |
|
|
| include hd hmem hm |
|
|
| lemma uniform_descendants (k : ℕ) : UniformDefinable S m 2 |
| (fun _ v => (v 0).val ∈ descendants (elements (v 1).val) k) := by |
| induction k with |
| | zero => exact hmem |
| | succ k ih => |
| have hleft := ih.reindex (![0,2] : Fin 2 → Fin 3) |
| have hright := hmem.reindex (![1,0] : Fin 2 → Fin 3) |
| apply (ih.or ((hleft.and hright).ex (by omega))).congr |
| intro i v |
| change ((v 0).val ∈ descendants (elements (v 1).val) k ∨ |
| ∃ z : Domain (d i), z.val ∈ descendants (elements (v 1).val) k ∧ |
| (v 0).val ∈ z.val) ↔ _ |
| simp only [descendants,Finset.mem_union,Finset.mem_biUnion] |
| apply or_congr Iff.rfl |
| constructor |
| · rintro ⟨z,hz,hy⟩; exact ⟨z.val,hz,hy⟩ |
| · rintro ⟨z,hz,hy⟩ |
| exact ⟨⟨z,TC_in_domain (d i) (hd i) (v 1).property z |
| (descendants_TC_subset _ _ hz)⟩,hz,hy⟩ |
|
|
| omit hmem hm in |
| lemma descendants_count_iff (i : ι) (x : Domain (d i)) (k j : ℕ) : |
| Nonempty ({y : Domain (d i) // y.val ∈ descendants (elements x.val) k} ≃ Fin j) ↔ |
| (descendants (elements x.val) k).card = j := by |
| let t := descendants (elements x.val) k |
| have ht : ∀ y ∈ t, y ∈ d i := fun y hy => |
| TC_in_domain (d i) (hd i) x.property y (descendants_TC_subset _ _ hy) |
| let e : {y : Domain (d i) // y.val ∈ t} ≃ {y // y ∈ t} := |
| { toFun := fun y => ⟨y.val.val,y.property⟩ |
| invFun := fun y => ⟨⟨y.val,ht y.val y.property⟩,y.property⟩ |
| left_inv := fun _ => rfl |
| right_inv := fun _ => rfl } |
| constructor |
| · rintro ⟨f⟩ |
| have hh := Fintype.card_congr (e.symm.trans f) |
| simpa [t] using hh |
| · intro hh |
| let f := (Fintype.equivFin {y // y ∈ t}).trans (finCongr (by simpa [t] using hh)) |
| exact ⟨e.trans f⟩ |
|
|
| lemma uniform_TC_bound (p : ℕ) : UniformDefinable S m 1 |
| (fun _ v => (TC (v 0).val).card ≤ p) := by |
| have hr := uniform_descendants d S hd hmem hm (p+1) |
| have hh := UniformDefinable.exists_finset (Finset.range (p+1)) |
| (fun j _ => hr.exact (by omega : 1 < m) j) |
| apply hh.congr |
| intro i v |
| simp only [Fin.cons_zero,Fin.cons_one,descendants_count_iff d hd,Finset.mem_range,Nat.lt_succ_iff] |
| rw [descendants_TC_bound] |
| exact ⟨fun ⟨j,hj,he⟩ => he ▸ hj,fun h => ⟨_,h,rfl⟩⟩ |
|
|
| end |
|
|
| end WitnessedChoice.BGS |
|
|
| namespace WitnessedChoice.BGS |
|
|
| noncomputable section |
|
|
| open Classical WitnessedSeparation WitnessedSeparation.Hereditary |
|
|
| abbrev Traced (A : Type) (X : Type) := X × Finset (HF A) |
|
|
| def tracedLoop {A : Type} (p : ℕ) (step : HF A → Traced A (HF A)) : |
| ℕ → HF A → Traced A (HF A) |
| | 0, _ => (emptyHF, closure emptyHF) |
| | fuel+1, x => |
| if (TC x).card ≤ p then |
| let r := step x |
| if x = r.1 then (x,r.2) else |
| let s := tracedLoop p step fuel r.1 |
| (s.1,r.2 ∪ s.2) |
| else (emptyHF,closure emptyHF) |
|
|
| mutual |
| def Term.traced {A : Type} [Fintype A] (S : Input A) (p : ℕ) : |
| {n : ℕ} → Term n → (Fin n → HF A) → Traced A (HF A) |
| | _, .var j, env => (env j,closure (env j)) |
| | _, .empty, _ => (emptyHF,closure emptyHF) |
| | _, .atoms, _ => |
| let x := ofFinset (Finset.univ.image atom) |
| (x,closure x) |
| | _, .pair a b, env => |
| let x := a.traced S p env |
| let y := b.traced S p env |
| (double x.1 y.1,insert (double x.1 y.1) (x.2 ∪ y.2)) |
| | _, .union a, env => |
| let x := a.traced S p env |
| (unionHF x.1,insert (unionHF x.1) x.2) |
| | _, .unique a, env => |
| let x := a.traced S p env |
| (uniqueHF x.1,insert (uniqueHF x.1) x.2) |
| | _, .card a, env => |
| let x := a.traced S p env |
| (cardHF x.1,closure (cardHF x.1) ∪ x.2) |
| | _, .comprehend body range guard, env => |
| let r := range.traced S p env |
| let test := fun x => guard.traced S p (Fin.cons x env) |
| let val := fun x => body.traced S p (Fin.cons x env) |
| let selected := (elements r.1).filter (fun x => (test x).1 = true) |
| let out := ofFinset (selected.image (fun x => (val x).1)) |
| (out, insert out (r.2 ∪ (elements r.1).biUnion (fun x => (test x).2) ∪ |
| selected.biUnion (fun x => (val x).2))) |
| | _, .iterate step, env => |
| tracedLoop p (fun x => step.traced S p (Fin.cons x env)) (p+1) emptyHF |
| def Formula.traced {A : Type} [Fintype A] (S : Input A) (p : ℕ) : |
| {n : ℕ} → Formula n → (Fin n → HF A) → Traced A Bool |
| | _, .equal a b, env => |
| let x := a.traced S p env |
| let y := b.traced S p env |
| (decide (x.1 = y.1),x.2 ∪ y.2) |
| | _, .input r a b, env => |
| let x := a.traced S p env |
| let y := b.traced S p env |
| (inputHF S r x.1 y.1,x.2 ∪ y.2) |
| | _, .neg a, env => |
| let x := a.traced S p env |
| (!x.1,x.2) |
| | _, .and a b, env => |
| let x := a.traced S p env |
| let y := b.traced S p env |
| (x.1 && y.1,x.2 ∪ y.2) |
| | _, .or a b, env => |
| let x := a.traced S p env |
| let y := b.traced S p env |
| (x.1 || y.1,x.2 ∪ y.2) |
| | _, .wsc _ _ _ _, _ => (false,∅) |
| end |
|
|
| variable {A : Type} [Fintype A] |
|
|
| omit [Fintype A] in |
| lemma iterationLoop_traced (q : ℕ) (step : HF A → Result (HF A)) |
| (ts : HF A → Traced A (HF A)) (h : ∀ x, step x = some (ts x).1) |
| (fuel : ℕ) (x : HF A) : |
| iterationLoop q step fuel x = some (tracedLoop q ts fuel x).1 := by |
| induction fuel generalizing x with |
| | zero => rfl |
| | succ fuel ih => |
| by_cases hx : (TC x).card ≤ q |
| · simp only [iterationLoop,tracedLoop,ite_eq_left hx,h x,Option.bind_some] |
| by_cases he : x = (ts x).1 |
| · simp only [ite_eq_left he] |
| · simp only [ite_eq_right he] |
| exact ih _ |
| · simp only [iterationLoop,tracedLoop,ite_eq_right hx] |
|
|
| mutual |
| theorem Term.eval_traced (S : Input A) (p : Polynomial ℝ) {n : ℕ} |
| (t : Term n) (ht : t.wscCount = 0) (env : Fin n → HF A) : |
| t.eval S p env = some (t.traced S (resource p (Fintype.card A)) env).1 := by |
| cases t with |
| | var j => rfl |
| | empty => rfl |
| | atoms => |
| simp only [Term.eval,Term.traced] |
| | pair a b => |
| have h := Nat.add_eq_zero_iff.mp ht |
| simp only [Term.eval,Term.traced,lift₂,a.eval_traced S p h.1 env, |
| b.eval_traced S p h.2 env,Option.bind_some,Option.map_some] |
| | union a => simp only [Term.eval,Term.traced,a.eval_traced S p ht env,Option.map_some] |
| | unique a => simp only [Term.eval,Term.traced,a.eval_traced S p ht env,Option.map_some] |
| | card a => simp only [Term.eval,Term.traced,a.eval_traced S p ht env,Option.map_some] |
| | comprehend body range guard => |
| have h := Nat.add_eq_zero_iff.mp ht |
| have h' := Nat.add_eq_zero_iff.mp h.1 |
| simp only [Term.eval,range.eval_traced S p h'.2 env,Option.bind_some] |
| have hg : ∀ x : HF A, guard.eval S p (Fin.cons x env) = |
| some (guard.traced S (resource p (Fintype.card A)) (Fin.cons x env)).1 := |
| fun x => guard.eval_traced S p h.2 _ |
| have hb : ∀ x : HF A, body.eval S p (Fin.cons x env) = |
| some (body.traced S (resource p (Fintype.card A)) (Fin.cons x env)).1 := |
| fun x => body.eval_traced S p h'.1 _ |
| simp only [collect,hg,hb,Option.isSome_some, |
| implies_true,and_self,ite_true,Option.getD_some,Term.traced,Option.some.injEq] |
| | iterate step => |
| exact iterationLoop_traced _ _ _ |
| (fun x => step.eval_traced S p ht (Fin.cons x env)) _ _ |
| theorem Formula.eval_traced (S : Input A) (p : Polynomial ℝ) {n : ℕ} |
| (f : Formula n) (hf : f.wscCount = 0) (env : Fin n → HF A) : |
| f.eval S p env = some (f.traced S (resource p (Fintype.card A)) env).1 := by |
| cases f with |
| | equal a b => |
| have h := Nat.add_eq_zero_iff.mp hf |
| simp only [Formula.eval,Formula.traced,lift₂,a.eval_traced S p h.1 env, |
| b.eval_traced S p h.2 env,Option.bind_some,Option.map_some] |
| | input r a b => |
| have h := Nat.add_eq_zero_iff.mp hf |
| simp only [Formula.eval,Formula.traced,lift₂,a.eval_traced S p h.1 env, |
| b.eval_traced S p h.2 env,Option.bind_some,Option.map_some] |
| | neg a => simp only [Formula.eval,Formula.traced,a.eval_traced S p hf env,Option.map_some] |
| | and a b => |
| have h := Nat.add_eq_zero_iff.mp hf |
| simp only [Formula.eval,Formula.traced,lift₂,a.eval_traced S p h.1 env, |
| b.eval_traced S p h.2 env,Option.bind_some,Option.map_some] |
| | or a b => |
| have h := Nat.add_eq_zero_iff.mp hf |
| simp only [Formula.eval,Formula.traced,lift₂,a.eval_traced S p h.1 env, |
| b.eval_traced S p h.2 env,Option.bind_some,Option.map_some] |
| | wsc step choice witness output => simp only [Formula.wscCount] at hf; omega |
| end |
|
|
| end |
|
|
| end WitnessedChoice.BGS |
|
|
| namespace WitnessedChoice.BGS |
|
|
| noncomputable section |
|
|
| open Classical WitnessedSeparation WitnessedSeparation.Hereditary |
|
|
| variable {A : Type} |
|
|
| def ClosedTrace (F : Finset (HF A)) : Prop := ∀ x ∈ F, closure x ⊆ F |
|
|
| lemma closedTrace_closure (x : HF A) : ClosedTrace (closure x) := by |
| intro y hy |
| exact closure_subset_of_transitive (fun z hz w hw => closure_transitive hz hw) hy |
|
|
| lemma closedTrace_union {F G : Finset (HF A)} (hF : ClosedTrace F) (hG : ClosedTrace G) : |
| ClosedTrace (F ∪ G) := by |
| intro x hx y hy |
| rcases Finset.mem_union.mp hx with hx | hx |
| · exact Finset.mem_union_left _ (hF _ hx hy) |
| · exact Finset.mem_union_right _ (hG _ hx hy) |
|
|
| lemma closedTrace_biUnion {X : Type} (t : Finset X) (f : X → Finset (HF A)) |
| (hf : ∀ x ∈ t, ClosedTrace (f x)) : ClosedTrace (t.biUnion f) := by |
| intro x hx y hy |
| obtain ⟨z,hz,hxz⟩ := Finset.mem_biUnion.mp hx |
| exact Finset.mem_biUnion.mpr ⟨z,hz,hf z hz _ hxz hy⟩ |
|
|
| lemma closedTrace_insert {F : Finset (HF A)} (hF : ClosedTrace F) (x : HF A) |
| (hx : closure x ⊆ insert x F) : ClosedTrace (insert x F) := by |
| intro y hy z hz |
| rcases Finset.mem_insert.mp hy with rfl | hy |
| · exact hx hz |
| · exact Finset.mem_insert_of_mem (hF y hy hz) |
|
|
| lemma closure_emptyHF : closure (emptyHF : HF A) = {emptyHF} := by |
| simp only [emptyHF,closure_ofFinset,familyClosure,Finset.biUnion_empty,Finset.insert_empty] |
|
|
| lemma closure_unionHF_subset (x : HF A) : |
| closure (unionHF x) ⊆ insert (unionHF x) (closure x) := by |
| rw [unionHF,closure_ofFinset] |
| intro z hz |
| simp only [Finset.mem_insert] at hz |
| rcases hz with he | hz |
| · exact Finset.mem_insert.mpr (Or.inl he) |
| apply Finset.mem_insert_of_mem |
| obtain ⟨y,hy,hzy⟩ := mem_familyClosure.mp hz |
| obtain ⟨w,hw,hyw⟩ := Finset.mem_biUnion.mp hy |
| exact (closure_member_subset hw) ((closure_member_subset hyw) hzy) |
|
|
| lemma closure_uniqueHF_subset (x : HF A) : |
| closure (uniqueHF x) ⊆ insert (uniqueHF x) (closure x) := by |
| unfold uniqueHF |
| split |
| · rename_i h |
| have hm : h.choose ∈ x := by |
| change h.choose ∈ elements x |
| exact Eq.mpr (congrArg (fun t : Finset (HF A) => h.choose ∈ t) h.choose_spec) |
| (Finset.mem_singleton_self _) |
| exact (closure_member_subset hm).trans (Finset.subset_insert _ _) |
| · rw [closure_emptyHF] |
| exact Finset.singleton_subset_iff.mpr (Finset.mem_insert_self _ _) |
|
|
| lemma tracedLoop_closure_subset (p : ℕ) (step : HF A → Traced A (HF A)) |
| (hs : ∀ x, closure (step x).1 ⊆ (step x).2) (fuel : ℕ) (x : HF A) : |
| closure (tracedLoop p step fuel x).1 ⊆ (tracedLoop p step fuel x).2 := by |
| induction fuel generalizing x with |
| | zero => exact Finset.Subset.refl _ |
| | succ fuel ih => |
| simp only [tracedLoop] |
| split_ifs with hb he |
| · calc |
| closure x = closure (step x).1 := congrArg closure he |
| _ ⊆ (step x).2 := hs x |
| · exact (ih _).trans Finset.subset_union_right |
| · exact Finset.Subset.refl _ |
|
|
| lemma tracedLoop_closed (p : ℕ) (step : HF A → Traced A (HF A)) |
| (hs : ∀ x, ClosedTrace (step x).2) (fuel : ℕ) (x : HF A) : |
| ClosedTrace (tracedLoop p step fuel x).2 := by |
| induction fuel generalizing x with |
| | zero => exact closedTrace_closure _ |
| | succ fuel ih => |
| simp only [tracedLoop] |
| split_ifs |
| · exact hs x |
| · exact closedTrace_union (hs x) (ih _) |
| · exact closedTrace_closure _ |
|
|
| variable [Fintype A] |
|
|
| lemma Term.traced_closure (S : Input A) (p : ℕ) {n : ℕ} (t : Term n) |
| (env : Fin n → HF A) : closure (t.traced S p env).1 ⊆ (t.traced S p env).2 := by |
| cases t with |
| | var j => exact Finset.Subset.refl _ |
| | empty => exact Finset.Subset.refl _ |
| | atoms => exact Finset.Subset.refl _ |
| | pair a b => |
| intro z hz |
| have hh := closure_double_subset _ _ hz |
| simp only [Term.traced,Finset.mem_insert,Finset.mem_union] at hh ⊢ |
| rcases hh with he | ha | hb |
| · exact Or.inl he |
| · exact Or.inr (Or.inl (a.traced_closure S p env ha)) |
| · exact Or.inr (Or.inr (b.traced_closure S p env hb)) |
| | union a => |
| exact (closure_unionHF_subset _).trans (Finset.insert_subset_insert _ (a.traced_closure S p env)) |
| | unique a => |
| exact (closure_uniqueHF_subset _).trans (Finset.insert_subset_insert _ (a.traced_closure S p env)) |
| | card a => exact Finset.subset_union_left |
| | comprehend body range guard => |
| simp only [Term.traced,closure_ofFinset] |
| intro z hz |
| simp only [Finset.mem_insert] at hz |
| rcases hz with he | hz |
| · exact Finset.mem_insert.mpr (Or.inl he) |
| apply Finset.mem_insert_of_mem |
| obtain ⟨y,hy,hzy⟩ := mem_familyClosure.mp hz |
| obtain ⟨x,hx,rfl⟩ := Finset.mem_image.mp hy |
| exact Finset.mem_union_right _ (Finset.mem_biUnion.mpr |
| ⟨x,hx,body.traced_closure S p _ hzy⟩) |
| | iterate step => |
| exact tracedLoop_closure_subset p _ (fun x => step.traced_closure S p (Fin.cons x env)) _ _ |
|
|
| lemma Term.traced_self (S : Input A) (p : ℕ) {n : ℕ} (t : Term n) |
| (env : Fin n → HF A) : (t.traced S p env).1 ∈ (t.traced S p env).2 := |
| t.traced_closure S p env (mem_closure_self _) |
|
|
| mutual |
| lemma Term.traced_closed (S : Input A) (p : ℕ) {n : ℕ} (t : Term n) |
| (env : Fin n → HF A) : ClosedTrace (t.traced S p env).2 := by |
| cases t with |
| | var j => exact closedTrace_closure _ |
| | empty => exact closedTrace_closure _ |
| | atoms => exact closedTrace_closure _ |
| | pair a b => |
| exact closedTrace_insert (closedTrace_union (a.traced_closed S p env) |
| (b.traced_closed S p env)) _ ((Term.pair a b).traced_closure S p env) |
| | union a => |
| exact closedTrace_insert (a.traced_closed S p env) _ ((Term.union a).traced_closure S p env) |
| | unique a => |
| exact closedTrace_insert (a.traced_closed S p env) _ ((Term.unique a).traced_closure S p env) |
| | card a => exact closedTrace_union (closedTrace_closure _) (a.traced_closed S p env) |
| | comprehend body range guard => |
| apply closedTrace_insert _ _ ((Term.comprehend body range guard).traced_closure S p env) |
| exact closedTrace_union (closedTrace_union (range.traced_closed S p env) |
| (closedTrace_biUnion _ _ (fun x _ => guard.traced_closed S p (Fin.cons x env)))) |
| (closedTrace_biUnion _ _ (fun x _ => body.traced_closed S p (Fin.cons x env))) |
| | iterate step => |
| exact tracedLoop_closed p _ (fun x => step.traced_closed S p (Fin.cons x env)) _ _ |
| lemma Formula.traced_closed (S : Input A) (p : ℕ) {n : ℕ} (f : Formula n) |
| (env : Fin n → HF A) : ClosedTrace (f.traced S p env).2 := by |
| cases f with |
| | equal a b | input r a b => exact closedTrace_union (a.traced_closed S p env) (b.traced_closed S p env) |
| | neg a => exact a.traced_closed S p env |
| | and a b | or a b => exact closedTrace_union (a.traced_closed S p env) (b.traced_closed S p env) |
| | wsc step choice witness output => intro x hx; exact False.elim (Finset.notMem_empty _ hx) |
| end |
|
|
| end |
|
|
| end WitnessedChoice.BGS |
|
|
| namespace WitnessedChoice.BGS |
|
|
| noncomputable section |
|
|
| open Classical WitnessedSeparation WitnessedSeparation.Hereditary Finset |
|
|
| variable {A : Type} |
|
|
| lemma closure_eq_insert_TC (x : HF A) : closure x = insert x (TC x) := by |
| rw [Hereditary.closure] |
| ext y |
| simp only [TC,mem_insert,mem_biUnion,mem_attach,true_and,Subtype.exists] |
| constructor <;> rintro (h | ⟨a,ha,h⟩) |
| · exact Or.inl h |
| · exact Or.inr ⟨a,ha,h⟩ |
| · exact Or.inl h |
| · exact Or.inr ⟨a,ha,h⟩ |
|
|
| lemma closure_card_le_TC (x : HF A) : (closure x).card ≤ (TC x).card+1 := by |
| rw [closure_eq_insert_TC] |
| exact card_insert_le _ _ |
|
|
| lemma card_closure_atoms [Fintype A] : |
| (closure (ofFinset (univ.image (atom (A := A))))).card ≤ Fintype.card A+1 := by |
| have he : familyClosure (univ.image (atom (A := A))) = univ.image atom := by |
| ext x |
| simp only [familyClosure,mem_biUnion,mem_image,mem_univ,true_and] |
| constructor |
| · rintro ⟨_,⟨a,rfl⟩,h⟩ |
| rw [closure_atom] at h |
| exact ⟨a,(Finset.mem_singleton.mp h).symm⟩ |
| · rintro ⟨a,rfl⟩ |
| exact ⟨atom a,⟨a,rfl⟩,mem_closure_self _⟩ |
| have hh : closure (ofFinset (univ.image (atom (A := A)))) = |
| insert (ofFinset (univ.image atom)) (univ.image atom) := by |
| rw [closure_ofFinset,he] |
| ext x |
| simp only [mem_insert,mem_image,mem_univ,true_and] |
| rw [hh] |
| exact (card_insert_le _ _).trans (Nat.add_le_add_right |
| (card_image_le.trans (by rw [card_univ])) 1) |
|
|
| lemma tracedLoop_card (p : ℕ) (step : HF A → Traced A (HF A)) (C : ℕ) |
| (hs : ∀ x, (TC x).card ≤ p → (step x).2.card ≤ C) (fuel : ℕ) (x : HF A) : |
| (tracedLoop p step fuel x).2.card ≤ fuel*C+1 := by |
| induction fuel generalizing x with |
| | zero => simp only [tracedLoop,closure_emptyHF,card_singleton,Nat.zero_mul,Nat.zero_add,le_refl] |
| | succ fuel ih => |
| simp only [tracedLoop] |
| split_ifs with hb he |
| · change (step x).2.card ≤ (fuel+1)*C+1 |
| have hh := hs x hb |
| simp only [Nat.add_mul,Nat.one_mul] |
| omega |
| · have hh := (card_union_le (step x).2 (tracedLoop p step fuel (step x).1).2).trans |
| (add_le_add (hs x hb) (ih (step x).1)) |
| calc |
| _ ≤ C + (fuel*C+1) := hh |
| _ = (fuel+1)*C+1 := by ring |
| · simp only [closure_emptyHF,card_singleton] |
| omega |
|
|
| mutual |
| def Term.traceBound : {n : ℕ} → Term n → Polynomial ℕ |
| | _, .var _ => .X |
| | _, .empty => 1 |
| | _, .atoms => .X |
| | _, .pair a b => 1+a.traceBound+b.traceBound |
| | _, .union a | _, .unique a => 1+a.traceBound |
| | _, .card a => 1+2*a.traceBound |
| | _, .comprehend body range guard => 1+range.traceBound+range.traceBound * |
| (guard.traceBound.comp (.X+range.traceBound)+body.traceBound.comp (.X+range.traceBound)) |
| | _, .iterate step => 1+.X*(step.traceBound.comp (2*.X)) |
| def Formula.traceBound : {n : ℕ} → Formula n → Polynomial ℕ |
| | _, .equal a b | _, .input _ a b => a.traceBound+b.traceBound |
| | _, .neg a => a.traceBound |
| | _, .and a b | _, .or a b => a.traceBound+b.traceBound |
| | _, .wsc _ _ _ _ => 0 |
| end |
|
|
| variable [Fintype A] |
|
|
| def tracePotential {n : ℕ} (p : ℕ) (env : Fin n → HF A) : ℕ := |
| Fintype.card A+p+1+∑ j, (closure (env j)).card |
|
|
| lemma tracePotential_var {n : ℕ} (p : ℕ) (env : Fin n → HF A) (j : Fin n) : |
| (closure (env j)).card ≤ tracePotential p env := by |
| unfold tracePotential |
| exact (single_le_sum (f := fun j => (closure (env j)).card) |
| (fun _ _ => Nat.zero_le _) (mem_univ j)).trans (Nat.le_add_left _ _) |
|
|
| lemma tracePotential_cons {n : ℕ} (p : ℕ) (env : Fin n → HF A) (x : HF A) : |
| tracePotential p (Fin.cons x env) = tracePotential p env+(closure x).card := by |
| simp only [tracePotential,Fin.sum_univ_succ,Fin.cons_zero,Fin.cons_succ] |
| omega |
|
|
| mutual |
| lemma Term.traced_card_le (S : Input A) (p : ℕ) {n : ℕ} (t : Term n) |
| (env : Fin n → HF A) (K : ℕ) (hK : tracePotential p env ≤ K) : |
| (t.traced S p env).2.card ≤ t.traceBound.eval K := by |
| cases t with |
| | var j => |
| simpa only [Term.traced,Term.traceBound,Polynomial.eval_X] using (tracePotential_var p env j).trans hK |
| | empty => |
| simp only [Term.traced,closure_emptyHF,card_singleton,Term.traceBound,Polynomial.eval_one,le_refl] |
| | atoms => |
| have hk : Fintype.card A+1 ≤ K := by unfold tracePotential at hK; omega |
| simpa only [Term.traced,Term.traceBound,Polynomial.eval_X] using card_closure_atoms.trans hk |
| | pair a b => |
| have ha := a.traced_card_le S p env K hK |
| have hb := b.traced_card_le S p env K hK |
| have hh := (card_insert_le (double (a.traced S p env).1 (b.traced S p env).1) |
| ((a.traced S p env).2 ∪ (b.traced S p env).2)).trans |
| (Nat.add_le_add_right (card_union_le _ _) 1) |
| simp only [Term.traced,Term.traceBound,Polynomial.eval_add,Polynomial.eval_one] |
| omega |
| | union a | unique a => |
| have ha := a.traced_card_le S p env K hK |
| have hh := card_insert_le (s := (a.traced S p env).2) |
| simp only [Term.traced,Term.traceBound,Polynomial.eval_add,Polynomial.eval_one] |
| exact (hh _).trans (by omega) |
| | card a => |
| have ha := a.traced_card_le S p env K hK |
| have hc : (closure (cardHF (a.traced S p env).1)).card ≤ a.traceBound.eval K+1 := by |
| rw [cardHF,card_closure_ordinal] |
| exact Nat.add_le_add_right ((card_le_card ((elements_subset_closure _).trans |
| (a.traced_closure S p env))).trans ha) 1 |
| have hh := (card_union_le _ _).trans (add_le_add hc ha) |
| simp only [Term.traced,Term.traceBound,Polynomial.eval_add,Polynomial.eval_one, |
| Polynomial.eval_mul,Polynomial.eval_ofNat] |
| exact hh.trans (by omega) |
| | comprehend body range guard => |
| have hr := range.traced_card_le S p env K hK |
| have hc : (elements (range.traced S p env).1).card ≤ range.traceBound.eval K := |
| (card_le_card ((elements_subset_closure _).trans (range.traced_closure S p env))).trans hr |
| have hen (x) (hx : x ∈ elements (range.traced S p env).1) : |
| tracePotential p (Fin.cons x env) ≤ K+range.traceBound.eval K := by |
| rw [tracePotential_cons] |
| exact add_le_add hK ((card_le_card ((closure_member_subset hx).trans |
| (range.traced_closure S p env))).trans hr) |
| let E := elements (range.traced S p env).1 |
| let D := E.filter (fun x => (guard.traced S p (Fin.cons x env)).1 = true) |
| have hg : (E.biUnion fun x => (guard.traced S p (Fin.cons x env)).2).card ≤ |
| range.traceBound.eval K*guard.traceBound.eval (K+range.traceBound.eval K) := by |
| apply card_biUnion_le.trans |
| apply (sum_le_card_nsmul E _ _ (fun x hx => guard.traced_card_le S p _ _ (hen x hx))).trans |
| simpa only [nsmul_eq_mul,Nat.cast_id] using Nat.mul_le_mul_right _ hc |
| have hb : (D.biUnion fun x => (body.traced S p (Fin.cons x env)).2).card ≤ |
| range.traceBound.eval K*body.traceBound.eval (K+range.traceBound.eval K) := by |
| apply card_biUnion_le.trans |
| apply (sum_le_card_nsmul D _ _ (fun x hx => body.traced_card_le S p _ _ |
| (hen x (mem_filter.mp hx).1))).trans |
| simpa only [nsmul_eq_mul,Nat.cast_id] using |
| Nat.mul_le_mul_right _ ((card_le_card (filter_subset _ _)).trans hc) |
| have hh := (card_insert_le (s := (range.traced S p env).2 ∪ |
| (E.biUnion fun x => (guard.traced S p (Fin.cons x env)).2) ∪ |
| (D.biUnion fun x => (body.traced S p (Fin.cons x env)).2)) |
| (ofFinset (D.image fun x => (body.traced S p (Fin.cons x env)).1))).trans |
| (Nat.add_le_add_right ((card_union_le _ _).trans |
| (add_le_add ((card_union_le _ _).trans (add_le_add hr hg)) hb)) 1) |
| simp only [Term.traced,Term.traceBound,Polynomial.eval_add,Polynomial.eval_one, |
| Polynomial.eval_mul,Polynomial.eval_comp,Polynomial.eval_X] |
| change (insert _ ((range.traced S p env).2 ∪ _ ∪ _)).card ≤ _ at hh |
| exact hh.trans (by ring_nf; omega) |
| | iterate step => |
| have hk : p+1 ≤ K := by unfold tracePotential at hK; omega |
| have hb := tracedLoop_card p (fun x => step.traced S p (Fin.cons x env)) |
| (step.traceBound.eval (2*K)) (fun x hx => step.traced_card_le S p _ _ (by |
| rw [tracePotential_cons] |
| have hc := (closure_card_le_TC x).trans (Nat.add_le_add_right hx 1) |
| omega)) (p+1) emptyHF |
| simp only [Term.traced,Term.traceBound,Polynomial.eval_add,Polynomial.eval_one, |
| Polynomial.eval_mul,Polynomial.eval_comp,Polynomial.eval_X,Polynomial.eval_ofNat] |
| exact hb.trans (by nlinarith [Nat.mul_le_mul_right (step.traceBound.eval (2*K)) hk]) |
| lemma Formula.traced_card_le (S : Input A) (p : ℕ) {n : ℕ} (f : Formula n) |
| (env : Fin n → HF A) (K : ℕ) (hK : tracePotential p env ≤ K) : |
| (f.traced S p env).2.card ≤ f.traceBound.eval K := by |
| cases f with |
| | equal a b | input r a b => |
| simp only [Formula.traced,Formula.traceBound,Polynomial.eval_add] |
| exact (card_union_le _ _).trans (add_le_add (a.traced_card_le S p env K hK) |
| (b.traced_card_le S p env K hK)) |
| | neg a => exact a.traced_card_le S p env K hK |
| | and a b | or a b => |
| simp only [Formula.traced,Formula.traceBound,Polynomial.eval_add] |
| exact (card_union_le _ _).trans (add_le_add (a.traced_card_le S p env K hK) |
| (b.traced_card_le S p env K hK)) |
| | wsc step choice witness output => simp only [Formula.traced,Formula.traceBound,Polynomial.eval_zero,card_empty,le_refl] |
| end |
|
|
| end |
|
|
| end WitnessedChoice.BGS |
|
|
| end |
|
|
| end OAI |
|
|
