| import OAI.ModelTheory.Choiceless.Operational |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| namespace CPTSeparation.Operational |
|
|
| open Classical Hereditary Counting HFCoding Finset |
|
|
| local instance {A : Type*} : DecidableEq (HF A) := Classical.decEq _ |
|
|
| variable {ι R : Type} {A : ι → Type} [finiteFamilyA : ∀ i, Fintype (A i)] |
|
|
| variable (d : ∀ i, Set (HF (A i))) (S : ∀ 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 S m 2 (fun _ v => (v 0).val ∈ (v 1).val)) |
|
|
| variable (hset : UniformDefinable S m 1 (fun _ v => isSet (v 0).val = true)) |
|
|
| variable (hm : 6 ≤ m) |
|
|
| omit ι A d hd in |
| lemma member_count_iff |
| {ι : Type} |
| {A : ι → Type} |
| [(i : ι) → Fintype (A i)] |
| (d : (i : ι) → Set (Hereditary.HF (A i))) |
| (hd : ∀ (i : ι), ∀ x ∈ d i, ∀ y ∈ x, y ∈ d i) (i : ι) (x : Domain (d i)) (n : ℕ) : |
| Nonempty ({y : Domain (d i) |
| let e : {y : Domain (d i) |
| { toFun := fun y => ⟨y.val.val,y.property⟩ |
| invFun := fun y => ⟨⟨y.val,hd i _ x.property _ y.property⟩,y.property⟩ |
| left_inv := fun _ => rfl |
| right_inv := fun _ => rfl } |
| constructor |
| · rintro ⟨f⟩ |
| have h := Fintype.card_congr (e.symm.trans f) |
| simpa using h |
| · intro h |
| let f := (Fintype.equivFin {y |
| exact ⟨e.trans f⟩ |
|
|
| include hd hmem hset hm |
|
|
| omit ι R A d S m hd hmem hset hm in |
| lemma uniform_double_value |
| {ι : Type} |
| {R : Type} |
| {A : ι → Type} |
| [(i : ι) → Fintype (A i)] |
| (d : (i : ι) → Set (Hereditary.HF (A i))) |
| (S : (i : ι) → Counting.Structure R (HFCoding.Domain (d i))) |
| {m : ℕ} |
| (hd : ∀ (i : ι), ∀ x ∈ d i, ∀ y ∈ x, y ∈ d i) |
| (hmem : Counting.UniformDefinable S m 2 fun _ v => (v 0).val ∈ (v 1).val) |
| (hset : Counting.UniformDefinable S m 1 fun _ v => Hereditary.isSet (v 0).val = true) |
| (hm : 6 ≤ m) : UniformDefinable S m 3 |
| (fun _ v => (v 0).val = double (v 1).val (v 2).val) := |
| (HFCoding.uniform_double S hmem hset hm).congr |
| (fun i v => HFCoding.doubleTest_iff (hd i) (v 0) (v 1) (v 2)) |
|
|
| omit ι R A d S m hd hmem hset hm in |
| lemma uniform_singleton_value |
| {ι : Type} |
| {R : Type} |
| {A : ι → Type} |
| [(i : ι) → Fintype (A i)] |
| (d : (i : ι) → Set (Hereditary.HF (A i))) |
| (S : (i : ι) → Counting.Structure R (HFCoding.Domain (d i))) |
| {m : ℕ} |
| (hd : ∀ (i : ι), ∀ x ∈ d i, ∀ y ∈ x, y ∈ d i) |
| (hmem : Counting.UniformDefinable S m 2 fun _ v => (v 0).val ∈ (v 1).val) |
| (hset : Counting.UniformDefinable S m 1 fun _ v => Hereditary.isSet (v 0).val = true) |
| (hm : 6 ≤ m) : UniformDefinable S m 2 |
| (fun _ v => (v 0).val = Hereditary.singleton (v 1).val) := |
| (HFCoding.uniform_singleton S hmem hset hm).congr |
| (fun i v => HFCoding.singletonTest_iff (hd i) (v 0) (v 1)) |
|
|
| include ha in |
| lemma uniform_atoms : UniformDefinable S m 1 (fun i v => (v 0).val = (allAtoms : HF (A i))) := by |
| have hs : UniformDefinable S m 2 (fun _ v => isSet (v 0).val = false) := by |
| apply (hset.reindex (![0] : Fin 1 → Fin 2)).neg.congr |
| intro i v; dsimp; cases isSet (v 0).val <;> simp |
| have hbody := (hmem.iff hs).all (by omega : 1 < m) |
| apply (hset.and hbody).congr |
| intro i v |
| change (isSet (v 0).val = true ∧ ∀ y : Domain (d i), |
| y.val ∈ (v 0).val ↔ isSet y.val = false) ↔ _ |
| constructor |
| · rintro ⟨h0,h⟩ |
| apply ext_sets h0 (isSet_ofFinset _) |
| intro y |
| simp only [mem_ofFinset,mem_image,mem_univ,true_and] |
| constructor |
| · intro hy |
| have ht := (h ⟨y,hd i _ (v 0).property _ hy⟩).mp hy |
| change isSet y = false at ht |
| rcases atom_or_set y with ⟨a,rfl⟩ | he |
| · exact ⟨a,rfl⟩ |
| · rw [he,isSet_ofFinset] at ht; contradiction |
| · rintro ⟨a,rfl⟩ |
| exact (h ⟨atom a,ha i a⟩).mpr rfl |
| · intro he |
| constructor |
| · rw [he]; exact isSet_ofFinset _ |
| · intro y |
| rw [he] |
| simp only [allAtoms,mem_ofFinset,mem_image,mem_univ,true_and] |
| constructor |
| · rintro ⟨a,he⟩; rw [← he]; rfl |
| · intro ht |
| rcases atom_or_set y.val with ⟨a,he⟩ | he |
| · exact ⟨a,he.symm⟩ |
| · rw [he,isSet_ofFinset] at ht; contradiction |
|
|
| omit ι R A d S m hd hmem hset hm in |
| lemma uniform_union |
| {ι : Type} |
| {R : Type} |
| {A : ι → Type} |
| [(i : ι) → Fintype (A i)] |
| (d : (i : ι) → Set (Hereditary.HF (A i))) |
| (S : (i : ι) → Counting.Structure R (HFCoding.Domain (d i))) |
| {m : ℕ} |
| (hd : ∀ (i : ι), ∀ x ∈ d i, ∀ y ∈ x, y ∈ d i) |
| (hmem : Counting.UniformDefinable S m 2 fun _ v => (v 0).val ∈ (v 1).val) |
| (hset : Counting.UniformDefinable S m 1 fun _ v => Hereditary.isSet (v 0).val = true) |
| (hm : 6 ≤ m) : UniformDefinable S m 2 |
| (fun _ v => (v 0).val = unionHF (v 1).val) := by |
| have hz : UniformDefinable S m 4 |
| (fun _ v => (v 0).val ∈ (v 3).val ∧ (v 1).val ∈ (v 0).val) := |
| (hmem.reindex (![0,3] : Fin 2 → Fin 4)).and (hmem.reindex (![1,0] : Fin 2 → Fin 4)) |
| have hleft : UniformDefinable S m 3 (fun _ v => (v 0).val ∈ (v 1).val) := |
| hmem.reindex (![0,1] : Fin 2 → Fin 3) |
| have hbody := (hleft.iff (hz.ex (by omega))).all (by omega : 2 < m) |
| have hset' := hset.reindex (![0] : Fin 1 → Fin 2) |
| apply (hset'.and hbody).congr |
| intro i v |
| change (isSet (v 0).val = true ∧ ∀ y : Domain (d i), |
| y.val ∈ (v 0).val ↔ ∃ z : Domain (d i), z.val ∈ (v 1).val ∧ y.val ∈ z.val) ↔ _ |
| have hmemu (y : HF (A i)) : y ∈ unionHF (v 1).val ↔ |
| ∃ z : Domain (d i), z.val ∈ (v 1).val ∧ y ∈ z.val := by |
| simp only [unionHF,mem_ofFinset,mem_biUnion] |
| constructor |
| · rintro ⟨z,hz,hy⟩ |
| exact ⟨⟨z,hd i _ (v 1).property _ hz⟩,hz,hy⟩ |
| · rintro ⟨z,hz,hy⟩; exact ⟨z.val,hz,hy⟩ |
| constructor |
| · rintro ⟨h0,h⟩ |
| apply ext_sets h0 (isSet_ofFinset _) |
| intro y |
| change y ∈ (v 0).val ↔ y ∈ unionHF (v 1).val |
| rw [hmemu] |
| constructor |
| · intro hy; exact (h ⟨y,hd i _ (v 0).property _ hy⟩).mp hy |
| · rintro ⟨z,hz,hy⟩ |
| exact (h ⟨y,hd i _ z.property _ hy⟩).mpr ⟨z,hz,hy⟩ |
| · intro he |
| constructor |
| · rw [he]; exact isSet_ofFinset _ |
| · intro y; rw [he,hmemu] |
|
|
| omit ι R A d S m hd hp hmem hset hm in |
| lemma uniform_unique |
| {ι : Type} |
| {R : Type} |
| {A : ι → Type} |
| [(i : ι) → Fintype (A i)] |
| (d : (i : ι) → Set (Hereditary.HF (A i))) |
| (S : (i : ι) → Counting.Structure R (HFCoding.Domain (d i))) |
| {m : ℕ} |
| (hd : ∀ (i : ι), ∀ x ∈ d i, ∀ y ∈ x, y ∈ d i) |
| (hp : ∀ (i : ι) (k : ℕ), Hereditary.ordinal k ∈ d i) |
| (hmem : Counting.UniformDefinable S m 2 fun _ v => (v 0).val ∈ (v 1).val) |
| (hset : Counting.UniformDefinable S m 1 fun _ v => Hereditary.isSet (v 0).val = true) |
| (hm : 6 ≤ m) : UniformDefinable S m 2 |
| (fun _ v => (v 0).val = uniqueHF (v 1).val) := by |
| have hsing := uniform_singleton_value d S hd hmem hset hm |
| have hyes := hsing.reindex (![1,0] : Fin 2 → Fin 2) |
| have hex : UniformDefinable S m 2 (fun i v => ∃ z : Domain (d i), |
| (v 1).val = Hereditary.singleton z.val) := by |
| apply ((hsing.reindex (![2,0] : Fin 2 → Fin 3)).ex (by omega)).congr |
| intro i v |
| apply exists_congr |
| intro z |
| rfl |
| have hempt := (HFCoding.uniform_ordinal S hmem hset hm hd hp 0).reindex (![0] : Fin 1 → Fin 2) |
| apply (hyes.or (hempt.and hex.neg)).congr |
| intro i v |
| change ((v 1).val = Hereditary.singleton (v 0).val ∨ |
| ((v 0).val = empty ∧ ¬ ∃ z : Domain (d i), (v 1).val = Hereditary.singleton z.val)) ↔ _ |
| have hs (z : HF (A i)) : (v 1).val = Hereditary.singleton z ↔ elements (v 1).val = {z} := by |
| constructor |
| · intro h; rw [h]; exact elements_ofFinset _ |
| · intro h |
| rcases atom_or_set (v 1).val with ⟨a,he⟩ | he |
| · rw [he,elements_atom] at h |
| exact False.elim (by simpa using congrArg Finset.card h) |
| · rw [he,h]; rfl |
| have hexi : (∃ z : Domain (d i), (v 1).val = Hereditary.singleton z.val) ↔ |
| ∃ z, elements (v 1).val = {z} := by |
| constructor |
| · rintro ⟨z,hz⟩; exact ⟨z.val,(hs _).mp hz⟩ |
| · rintro ⟨z,hz⟩ |
| exact ⟨⟨z,hd i _ (v 1).property _ (by change z ∈ elements (v 1).val; rw [hz]; simp)⟩,(hs z).mpr hz⟩ |
| rw [hs,hexi] |
| rcases uniqueHF_spec (v 1).val with ⟨z,hz,he⟩ | ⟨hne,he⟩ |
| · rw [he,hz] |
| simp only [Finset.singleton_inj,exists_eq',not_true_eq_false,and_false,or_false] |
| exact eq_comm |
| · rw [he] |
| constructor |
| · rintro (h | ⟨h,_⟩) |
| · exact False.elim (hne ⟨_,h⟩) |
| · exact h |
| · intro h; exact Or.inr ⟨h,hne⟩ |
| |
| def BoundedCard (K : ℕ) {i : ι} (z x : Domain (d i)) : Prop := |
| (elements x.val).card ≤ K ∧ z.val = cardinalityHF x.val |
| |
| omit ι R A d S m hd hp hmem hset hm in |
| lemma uniform_card |
| {ι : Type} |
| {R : Type} |
| {A : ι → Type} |
| [(i : ι) → Fintype (A i)] |
| (d : (i : ι) → Set (Hereditary.HF (A i))) |
| (S : (i : ι) → Counting.Structure R (HFCoding.Domain (d i))) |
| {m : ℕ} |
| (hd : ∀ (i : ι), ∀ x ∈ d i, ∀ y ∈ x, y ∈ d i) |
| (hp : ∀ (i : ι) (k : ℕ), Hereditary.ordinal k ∈ d i) |
| (hmem : Counting.UniformDefinable S m 2 fun _ v => (v 0).val ∈ (v 1).val) |
| (hset : Counting.UniformDefinable S m 1 fun _ v => Hereditary.isSet (v 0).val = true) |
| (hm : 6 ≤ m) (K : ℕ) : UniformDefinable S m 2 |
| (fun _ v => BoundedCard d K (v 0) (v 1)) := by |
| have hmemb : UniformDefinable S m 3 (fun _ v => (v 0).val ∈ (v 2).val) := |
| hmem.reindex (![0,2] : Fin 2 → Fin 3) |
| have hdis : UniformDefinable S m 2 (fun i v => ∃ n ∈ range (K+1), |
| Nonempty ({y : Domain (d i) // y.val ∈ (v 1).val} ≃ Fin n) ∧ (v 0).val = ordinal n) := by |
| apply UniformDefinable.exists_finset |
| intro n hn |
| have hc := hmemb.exact (by omega) n |
| have ho := (HFCoding.uniform_ordinal S hmem hset hm hd hp n).reindex (![0] : Fin 1 → Fin 2) |
| exact hc.and ho |
| apply hdis.congr |
| intro i v |
| simp only [member_count_iff d hd,mem_range,BoundedCard,cardinalityHF] |
| constructor |
| · rintro ⟨n,hn,hc,he⟩; exact ⟨by omega,by rwa [hc]⟩ |
| · rintro ⟨hc,he⟩; exact ⟨_,by omega,rfl,he⟩ |
| |
| omit ι R A d S m hd hp hmem hset hm in |
| lemma uniform_boolean |
| {ι : Type} |
| {R : Type} |
| {A : ι → Type} |
| [(i : ι) → Fintype (A i)] |
| (d : (i : ι) → Set (Hereditary.HF (A i))) |
| (S : (i : ι) → Counting.Structure R (HFCoding.Domain (d i))) |
| {m : ℕ} |
| (hd : ∀ (i : ι), ∀ x ∈ d i, ∀ y ∈ x, y ∈ d i) |
| (hp : ∀ (i : ι) (k : ℕ), Hereditary.ordinal k ∈ d i) |
| (hmem : Counting.UniformDefinable S m 2 fun _ v => (v 0).val ∈ (v 1).val) |
| (hset : Counting.UniformDefinable S m 1 fun _ v => Hereditary.isSet (v 0).val = true) |
| (hm : 6 ≤ m) {n : ℕ} {P : ∀ i, (Fin (n+1) → Domain (d i)) → Prop} |
| (hP : UniformDefinable S m (n+1) P) : |
| UniformDefinable S m (n+1) (fun i v => (v 0).val = boolean (P i v)) := by |
| have ht := (HFCoding.uniform_ordinal S hmem hset hm hd hp 1).reindex (![0] : Fin 1 → Fin (n+1)) |
| have hf := (HFCoding.uniform_ordinal S hmem hset hm hd hp 0).reindex (![0] : Fin 1 → Fin (n+1)) |
| apply ((ht.and hP).or (hf.and hP.neg)).congr |
| intro i v |
| change ((v 0).val = truth ∧ P i v ∨ (v 0).val = empty ∧ ¬ P i v) ↔ _ |
| by_cases hh : P i v <;> simp [boolean,hh] |
| |
| end CPTSeparation.Operational |
| |
| namespace CPTSeparation.Counting.UniformDefinable |
| |
| open Classical Finset |
| |
| variable {ι R : Type} {D : ι → Type} {S : ∀ i, Structure R (D i)} {m n r : ℕ} |
| |
| lemma forall_finset {X : Type} {P : X → ∀ i, (Fin n → D i) → Prop} (t : Finset X) |
| (h : ∀ a ∈ t, UniformDefinable S m n (P a)) : |
| UniformDefinable S m n (fun i v => ∀ a ∈ t, P a i v) := by |
| apply (exists_finset t (fun a ha => (h a ha).neg)).neg.congr |
| intro i v; simp |
| |
| lemma forall_finite {X : Type} [Fintype X] {P : X → ∀ i, (Fin n → D i) → Prop} |
| (h : ∀ a, UniformDefinable S m n (P a)) : |
| UniformDefinable S m n (fun i v => ∀ a, P a i v) := by |
| simpa only [Finset.mem_univ,true_implies] using forall_finset univ (fun a _ => h a) |
| |
| lemma append_cons {X : Type} (x : X) (u : Fin r → X) (v : Fin n → X) : |
| Fin.append (Fin.cons x u) v = Fin.cons x (Fin.append u v) ∘ |
| (finCongr (by omega : (r+1)+n = r+n+1)) := by |
| rw [Fin.append_cons] |
| congr 1 |
| |
| lemma exists_vec {P : ∀ i, (Fin (r+n) → D i) → Prop} |
| (h : UniformDefinable S m (r+n) P) (hroom : r+n ≤ m) : |
| UniformDefinable S m n (fun i v => ∃ u : Fin r → D i, P i (Fin.append u v)) := by |
| induction r with |
| | zero => |
| have h' := h.reindex (finCongr (Nat.zero_add n)) |
| apply h'.congr |
| intro i v |
| have he (u : Fin 0 → D i) : Fin.append u v = v ∘ finCongr (Nat.zero_add n) := by |
| rw [Fin.append_left_nil u v rfl] |
| congr 1 |
| constructor |
| · intro hp; exact ⟨Fin.elim0,by rw [he]; exact hp⟩ |
| · rintro ⟨u,hp⟩; rwa [he] at hp |
| | succ r ih => |
| have h' := h.reindex (finCongr (by omega : (r+1)+n = (r+n)+1)) |
| have he := h'.ex (by omega) |
| have hi := ih he (by omega) |
| apply hi.congr |
| intro i v |
| constructor |
| · rintro ⟨u,x,hp⟩ |
| exact ⟨Fin.cons x u,by simpa only [append_cons] using hp⟩ |
| · rintro ⟨u,hp⟩ |
| refine ⟨Fin.tail u,u 0,?_⟩ |
| simpa only [← append_cons,Fin.cons_self_tail] using hp |
| |
| lemma compose_unary {P : ∀ i, (Fin (n+1) → D i) → Prop} |
| {Q : ∀ i, (Fin 2 → D i) → Prop} |
| (hP : UniformDefinable S m (n+1) P) (hQ : UniformDefinable S m 2 Q) |
| (hr : n+1 < m) : UniformDefinable S m (n+1) |
| (fun i v => ∃ x, P i (Fin.cons x (Fin.tail v)) ∧ Q i ![v 0,x]) := by |
| have h1 := hP.reindex (Fin.cons 0 (fun j => j.succ.succ) : Fin (n+1) → Fin (n+2)) |
| have h2 := hQ.reindex (![1,0] : Fin 2 → Fin (n+2)) |
| apply ((h1.and h2).ex hr).congr |
| intro i v |
| apply exists_congr; intro x |
| have he : Fin.cons x v ∘ (Fin.cons 0 (fun j => j.succ.succ) : Fin (n+1) → Fin (n+2)) = |
| Fin.cons x (Fin.tail v) := by funext j; refine Fin.cases rfl (fun _ => rfl) j |
| have he2 : Fin.cons x v ∘ (![1,0] : Fin 2 → Fin (n+2)) = ![v 0,x] := by |
| funext j; fin_cases j <;> rfl |
| simp only [he,he2] |
| |
| lemma compose_binary {P Q : ∀ i, (Fin (n+1) → D i) → Prop} |
| {T : ∀ i, (Fin 3 → D i) → Prop} |
| (hP : UniformDefinable S m (n+1) P) (hQ : UniformDefinable S m (n+1) Q) |
| (hT : UniformDefinable S m 3 T) (hr : n+2 < m) : |
| UniformDefinable S m (n+1) (fun i v => ∃ x y, |
| P i (Fin.cons x (Fin.tail v)) ∧ Q i (Fin.cons y (Fin.tail v)) ∧ T i ![v 0,x,y]) := by |
| have h1 := hP.reindex (Fin.cons 1 (fun j => j.succ.succ.succ) : Fin (n+1) → Fin (n+3)) |
| have h2 := hQ.reindex (Fin.cons 0 (fun j => j.succ.succ.succ) : Fin (n+1) → Fin (n+3)) |
| have h3 := hT.reindex (![2,1,0] : Fin 3 → Fin (n+3)) |
| 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 he1 : Fin.cons y (Fin.cons x v) ∘ |
| (Fin.cons 1 (fun j => j.succ.succ.succ) : Fin (n+1) → Fin (n+3)) = |
| Fin.cons x (Fin.tail v) := by funext j; refine Fin.cases rfl (fun _ => rfl) j |
| have he2 : Fin.cons y (Fin.cons x v) ∘ |
| (Fin.cons 0 (fun j => j.succ.succ.succ) : Fin (n+1) → Fin (n+3)) = |
| Fin.cons y (Fin.tail v) := by funext j; refine Fin.cases rfl (fun _ => rfl) j |
| have he3 : Fin.cons y (Fin.cons x v) ∘ (![2,1,0] : Fin 3 → Fin (n+3)) = ![v 0,x,y] := by |
| funext j; fin_cases j <;> rfl |
| simp only [he1,he2,he3] |
| |
| lemma compose_vec {P : Fin r → ∀ i, (Fin (n+1) → D i) → Prop} |
| {Q : ∀ i, (Fin (r+1) → D i) → Prop} |
| (hP : ∀ j, UniformDefinable S m (n+1) (P j)) (hQ : UniformDefinable S m (r+1) Q) |
| (hr : r+(n+1) ≤ m) : UniformDefinable S m (n+1) |
| (fun i v => ∃ w : Fin r → D i, |
| (∀ j, P j i (Fin.cons (w j) (Fin.tail v))) ∧ Q i (Fin.cons (v 0) w)) := by |
| let ix (j : Fin r) : Fin (n+1) → Fin (r+(n+1)) := |
| Fin.cons (j.castAdd (n+1)) (fun l => l.succ.natAdd r) |
| let iq : Fin (r+1) → Fin (r+(n+1)) := |
| Fin.cons ((0 : Fin (n+1)).natAdd r) (fun j => j.castAdd (n+1)) |
| have h1 := forall_finite (fun j => (hP j).reindex (ix j)) |
| have h2 := hQ.reindex iq |
| apply ((h1.and h2).exists_vec hr).congr |
| intro i v |
| apply exists_congr |
| intro w |
| have he1 (j : Fin r) : Fin.append w v ∘ ix j = Fin.cons (w j) (Fin.tail v) := by |
| funext l |
| refine Fin.cases ?_ (fun l => ?_) l |
| · exact Fin.append_left _ _ _ |
| · exact Fin.append_right _ _ _ |
| have he2 : Fin.append w v ∘ iq = Fin.cons (v 0) w := by |
| funext l |
| refine Fin.cases ?_ (fun l => ?_) l |
| · exact Fin.append_right _ _ _ |
| · exact Fin.append_left _ _ _ |
| simp only [he1,he2] |
| |
| end CPTSeparation.Counting.UniformDefinable |
| |
| namespace CPTSeparation.Operational.Term |
| |
| open Classical Hereditary Counting HFCoding Finset |
| |
| local instance {A : Type*} : DecidableEq (HF A) := Classical.decEq _ |
| |
| variable {A R F : Type} {arity : F → ℕ} [Fintype A] |
| |
| def Graph (d : Set (HF A)) (K : ℕ) (rel : R → A → A → Bool) (s : State F arity A) : |
| {k : ℕ} → Term R F arity k → Domain d → (Fin k → Domain d) → Prop |
| | _,.var j,z,v => z = v j |
| | _,.constant n,z,_ => z.val = ordinal n |
| | _,.atoms,z,_ => z.val = allAtoms |
| | _,.app f args,z,v => ∃ w : Fin (arity f) → Domain d, |
| (∀ j, Graph d K rel s (args j) (w j) v) ∧ z.val = s.value ⟨f,fun j => (w j).val⟩ |
| | _,.pair a b,z,v => ∃ x y, Graph d K rel s a x v ∧ Graph d K rel s b y v ∧ z.val = double x.val y.val |
| | _,.union a,z,v => ∃ x, Graph d K rel s a x v ∧ z.val = unionHF x.val |
| | _,.unique a,z,v => ∃ x, Graph d K rel s a x v ∧ z.val = uniqueHF x.val |
| | _,.card a,z,v => ∃ x, Graph d K rel s a x v ∧ (elements x.val).card ≤ K ∧ z.val = cardinalityHF x.val |
| | _,.equal a b,z,v => ∃ x y, Graph d K rel s a x v ∧ Graph d K rel s b y v ∧ z.val = boolean (x.val = y.val) |
| | _,.member a b,z,v => ∃ x y, Graph d K rel s a x v ∧ Graph d K rel s b y v ∧ z.val = boolean (x.val ∈ y.val) |
| | _,.isAtom a,z,v => ∃ x, Graph d K rel s a x v ∧ z.val = boolean (isSet x.val = false) |
| | _,.input r a b,z,v => ∃ x y, Graph d K rel s a x v ∧ Graph d K rel s b y v ∧ z.val = boolean (inputRelation rel r x.val y.val) |
| | _,.not a,z,v => ∃ x, Graph d K rel s a x v ∧ z.val = boolean (x.val ≠ truth) |
| | _,.and a b,z,v => ∃ x y, Graph d K rel s a x v ∧ Graph d K rel s b y v ∧ z.val = boolean (x.val = truth ∧ y.val = truth) |
| | _,.conditional c a b,z,v => ∃ x, Graph d K rel s c x v ∧ |
| ((x.val = truth ∧ Graph d K rel s a z v) ∨ (x.val ≠ truth ∧ Graph d K rel s b z v)) |
| | _,.comprehension bound guard body,z,v => ∃ b, Graph d K rel s bound b v ∧ |
| (∀ x : Domain d, x.val ∈ b.val → ∃ g y, Graph d K rel s guard g (Fin.cons x v) ∧ Graph d K rel s body y (Fin.cons x v)) ∧ |
| isSet z.val = true ∧ ∀ y : Domain d, y.val ∈ z.val ↔ ∃ x : Domain d, |
| x.val ∈ b.val ∧ (∃ g, Graph d K rel s guard g (Fin.cons x v) ∧ g.val = truth) ∧ |
| Graph d K rel s body y (Fin.cons x v) |
| |
| variable (d : Set (HF A)) (K : ℕ) (rel : R → A → A → Bool) (s : State F arity A) |
| |
| variable (hd : ∀ x ∈ d, ∀ y, y ∈ x → y ∈ d) |
| |
| include hd in |
| lemma graph_sound {k : ℕ} (t : Term R F arity k) (z : Domain d) (v : Fin k → Domain d) |
| (h : Graph d K rel s t z v) : z.val = t.eval rel s (fun j => (v j).val) := by |
| induction t generalizing z with |
| | var j => exact congrArg Subtype.val h |
| | constant n => exact h |
| | atoms => exact h |
| | app f args ih => |
| obtain ⟨w,hw,hz⟩ := h |
| have he : (fun j => (w j).val) = fun j => (args j).eval rel s (fun j => (v j).val) := funext (fun j => ih j _ _ (hw j)) |
| simpa only [eval,he] using hz |
| | pair a b iha ihb | equal a b iha ihb | member a b iha ihb | input r a b iha ihb | and a b iha ihb => |
| obtain ⟨x,y,hx,hy,hz⟩ := h |
| simpa only [eval,iha _ _ hx,ihb _ _ hy] using hz |
| | union a ih | unique a ih | isAtom a ih | not a ih => |
| obtain ⟨x,hx,hz⟩ := h |
| simpa only [eval,ih _ _ hx] using hz |
| | card a ih => |
| obtain ⟨x,hx,_,hz⟩ := h |
| simpa only [eval,ih _ _ hx] using hz |
| | conditional c a b ihc iha ihb => |
| obtain ⟨x,hx,h⟩ := h |
| have he := ihc _ _ hx |
| rcases h with ⟨ht,h⟩ | ⟨ht,h⟩ |
| · simpa only [eval,← he,ite_eq_left ht] using iha _ _ h |
| · simpa only [eval,← he,ite_eq_right ht] using ihb _ _ h |
| | @comprehension k bound guard body ihb ihg ihy => |
| obtain ⟨b,hb,hall,hz,hmem⟩ := h |
| have heb := ihb _ _ hb |
| apply ext_sets hz (isSet_ofFinset _) |
| intro y |
| |
| simp only [mem_ofFinset,mem_image,mem_filter] |
| have hc (x : Domain d) : (fun j : Fin (k+1) => ((Fin.cons x v : Fin (k+1) → Domain d) j).val) = Fin.cons x.val (fun j => (v j).val) := by |
| funext j; refine Fin.cases rfl (fun _ => rfl) j |
| constructor |
| · intro hy |
| obtain ⟨x,hxb,⟨g,hg,hgt⟩,hyb⟩ := (hmem ⟨y,hd _ z.property _ hy⟩).mp hy |
| refine ⟨x.val,⟨by rwa [← heb],?_⟩,?_⟩ |
| · rw [← hc x,← ihg _ _ hg]; exact hgt |
| · have he : y = body.eval rel s (Fin.cons x.val (fun j => (v j).val)) := by |
| simpa only [hc] using ihy _ _ hyb |
| exact he.symm |
| · rintro ⟨x,⟨hxb,hgt⟩,heq⟩ |
| have hxd : x ∈ d := hd _ b.property _ (by rwa [heb]) |
| let xx : Domain d := ⟨x,hxd⟩ |
| obtain ⟨g,w,hg,hw⟩ := hall xx (by change x ∈ b.val; rwa [heb]) |
| have hgw := ihg _ _ hg |
| have hyw := ihy _ _ hw |
| simp only [hc] at hgw hyw |
| have hyw' : w.val = y := hyw.trans heq |
| have hyd : y ∈ d := hyw' ▸ w.property |
| apply (hmem ⟨y,hyd⟩).mpr |
| refine ⟨xx,by change x ∈ b.val; rwa [heb],⟨g,hg,?_⟩,?_⟩ |
| · exact hgw.trans hgt |
| · have he : w = (⟨y,hyd⟩ : Domain d) := Subtype.ext hyw' |
| rwa [← he] |
|
|
| lemma eval_mem_trace {k : ℕ} (t : Term R F arity k) (v : Fin k → HF A) : |
| t.eval rel s v ∈ t.trace rel s v := |
| closure_eval_subset_trace rel s t v (mem_closure_self _) |
|
|
| include hd in |
| lemma graph_complete {k : ℕ} (t : Term R F arity k) (v : Fin k → Domain d) |
| (ht : ∀ x ∈ t.trace rel s (fun j => (v j).val), x ∈ d ∧ (elements x).card ≤ K) : |
| ∃ z : Domain d, Graph d K rel s t z v ∧ z.val = t.eval rel s (fun j => (v j).val) := by |
| have result {k : ℕ} (t : Term R F arity k) (v : Fin k → Domain d) |
| (ht : ∀ x ∈ t.trace rel s (fun j => (v j).val), x ∈ d ∧ (elements x).card ≤ K) : |
| t.eval rel s (fun j => (v j).val) ∈ d := (ht _ (eval_mem_trace rel s t _)).1 |
| induction t with |
| | var j => exact ⟨v j,rfl,rfl⟩ |
| | constant n => exact ⟨⟨ordinal n,result _ _ ht⟩,rfl,rfl⟩ |
| | atoms => exact ⟨⟨allAtoms,result _ _ ht⟩,rfl,rfl⟩ |
| | app f args ih => |
| have hall : ∀ j, ∃ x : Domain d, Graph d K rel s (args j) x v ∧ |
| x.val = (args j).eval rel s (fun j => (v j).val) := by |
| intro j |
| apply ih j |
| intro x hx |
| apply ht x |
| exact mem_union_right _ (mem_biUnion.mpr ⟨j,mem_univ _,hx⟩) |
| choose w hw using hall |
| refine ⟨⟨_,result _ _ ht⟩,⟨w,fun j => (hw j).1,?_⟩,rfl⟩ |
| change s.value _ = s.value _ |
| congr 1 |
| exact Sigma.ext rfl (heq_of_eq (funext (fun j => (hw j).2.symm))) |
| | pair a b iha ihb | equal a b iha ihb | member a b iha ihb | input r a b iha ihb | and a b iha ihb => |
| obtain ⟨x,hx,hex⟩ := iha v (by |
| intro x hx; apply ht x; simp only [trace,mem_union]; tauto) |
| obtain ⟨y,hy,hey⟩ := ihb v (by |
| intro x hx; apply ht x; simp only [trace,mem_union]; tauto) |
| refine ⟨⟨_,result _ _ ht⟩,⟨x,y,hx,hy,?_⟩,rfl⟩ |
| simp only [eval,hex,hey] |
| | union a ih | unique a ih | isAtom a ih | not a ih => |
| obtain ⟨x,hx,hex⟩ := ih v (by |
| intro x hx; apply ht x; exact mem_union_right _ hx) |
| refine ⟨⟨_,result _ _ ht⟩,⟨x,hx,?_⟩,rfl⟩ |
| simp only [eval,hex] |
| | card a ih => |
| obtain ⟨x,hx,hex⟩ := ih v (by |
| intro x hx; apply ht x; exact mem_union_right _ hx) |
| refine ⟨⟨_,result _ _ ht⟩,⟨x,hx,?_,?_⟩,rfl⟩ |
| · rw [hex]; exact (ht _ (mem_union_right _ (eval_mem_trace rel s a _))).2 |
| · simp only [eval,hex] |
| | conditional c a b ihc iha ihb => |
| obtain ⟨x,hx,hex⟩ := ihc v (by |
| intro x hx; apply ht x; simp only [trace,mem_union]; tauto) |
| by_cases hc : x.val = truth |
| · obtain ⟨z,hz,hez⟩ := iha v (by |
| intro x hx; apply ht x; simp only [trace,mem_union]; tauto) |
| refine ⟨z,⟨x,hx,Or.inl ⟨hc,hz⟩⟩,?_⟩ |
| simpa only [eval,← hex,ite_eq_left hc] using hez |
| · obtain ⟨z,hz,hez⟩ := ihb v (by |
| intro x hx; apply ht x; simp only [trace,mem_union]; tauto) |
| refine ⟨z,⟨x,hx,Or.inr ⟨hc,hz⟩⟩,?_⟩ |
| simpa only [eval,← hex,ite_eq_right hc] using hez |
| | @comprehension k bound guard body ihb ihg ihy => |
| obtain ⟨b,hb,heb⟩ := ihb v (by |
| intro x hx; apply ht x; exact mem_insert_of_mem (mem_union_left _ hx)) |
| have hc (x : Domain d) : (fun j : Fin (k+1) => ((Fin.cons x v : Fin (k+1) → Domain d) j).val) = |
| Fin.cons x.val (fun j => (v j).val) := by |
| funext j; refine Fin.cases rfl (fun _ => rfl) j |
| have hall (x : Domain d) (hxb : x.val ∈ b.val) : |
| (∃ g, Graph d K rel s guard g (Fin.cons x v) ∧ g.val = guard.eval rel s (Fin.cons x.val (fun j => (v j).val))) ∧ |
| (∃ y, Graph d K rel s body y (Fin.cons x v) ∧ y.val = body.eval rel s (Fin.cons x.val (fun j => (v j).val))) := by |
| constructor |
| · have hh := ihg (Fin.cons x v) (by |
| intro y hy; apply ht y |
| apply mem_insert_of_mem |
| apply mem_union_right |
| apply mem_biUnion.mpr |
| refine ⟨x.val,by rwa [← heb],?_⟩ |
| apply mem_union_left |
| simpa only [hc] using hy) |
| simpa only [hc] using hh |
| · have hh := ihy (Fin.cons x v) (by |
| intro y hy; apply ht y |
| apply mem_insert_of_mem |
| apply mem_union_right |
| apply mem_biUnion.mpr |
| refine ⟨x.val,by rwa [← heb],?_⟩ |
| apply mem_union_right |
| simpa only [hc] using hy) |
| simpa only [hc] using hh |
| let z : Domain d := ⟨_,result _ _ ht⟩ |
| refine ⟨z,⟨b,hb,?_,isSet_ofFinset _,?_⟩,rfl⟩ |
| · intro x hx |
| obtain ⟨⟨g,hg,_⟩,⟨y,hy,_⟩⟩ := hall x hx |
| exact ⟨g,y,hg,hy⟩ |
| · intro y |
| change y.val ∈ ofFinset _ ↔ _ |
| simp only [mem_ofFinset,mem_image,mem_filter] |
| constructor |
| · rintro ⟨x,⟨hx,htrue⟩,hy⟩ |
| have hxd : x ∈ d := (ht _ (mem_insert_of_mem (mem_union_left _ |
| (closure_eval_subset_trace rel s bound _ (elements_subset_closure _ hx))))).1 |
| let xx : Domain d := ⟨x,hxd⟩ |
| have hxb : xx.val ∈ b.val := by change x ∈ b.val; rwa [heb] |
| obtain ⟨⟨g,hg,heg⟩,⟨w,hw,hew⟩⟩ := hall xx hxb |
| refine ⟨xx,hxb,⟨g,hg,heg.trans htrue⟩,?_⟩ |
| have he : w = y := Subtype.ext (hew.trans hy) |
| rwa [← he] |
| · rintro ⟨x,hxb,⟨g,hg,hgt⟩,hy⟩ |
| have heg := graph_sound d K rel s hd guard g (Fin.cons x v) hg |
| have hey := graph_sound d K rel s hd body y (Fin.cons x v) hy |
| simp only [hc] at heg hey |
| exact ⟨x.val,⟨by rwa [← heb],heg.symm.trans hgt⟩,hey.symm⟩ |
|
|
| end CPTSeparation.Operational.Term |
|
|
| namespace CPTSeparation.Operational |
|
|
| open Classical Hereditary Counting HFCoding Finset |
|
|
| variable {ι R : Type} {A : ι → Type} (d : ∀ i, Set (HF (A i))) |
|
|
| variable (S : ∀ i, Counting.Structure R (Domain (d i))) {m k : ℕ} |
|
|
| variable (hmem : UniformDefinable S m 2 (fun _ v => (v 0).val ∈ (v 1).val)) |
|
|
| variable (hset : UniformDefinable S m 1 (fun _ v => isSet (v 0).val = true)) |
|
|
| variable (htruth : UniformDefinable S m 1 (fun _ v => (v 0).val = truth)) |
|
|
| include hmem hset htruth in |
| lemma uniform_comprehension |
| {P : ∀ i, Domain (d i) → (Fin k → Domain (d i)) → Prop} |
| {Q T : ∀ i, Domain (d i) → (Fin (k+1) → Domain (d i)) → Prop} |
| (hP : UniformDefinable S m (k+1) (fun i v => P i (v 0) (Fin.tail v))) |
| (hQ : UniformDefinable S m (k+2) (fun i v => Q i (v 0) (Fin.tail v))) |
| (hT : UniformDefinable S m (k+2) (fun i v => T i (v 0) (Fin.tail v))) |
| (hm : k+5 ≤ m) : UniformDefinable S m (k+1) (fun i v => ∃ b, |
| P i b (Fin.tail v) ∧ |
| (∀ x : Domain (d i), x.val ∈ b.val → ∃ g y, |
| Q i g (Fin.cons x (Fin.tail v)) ∧ T 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 ∈ b.val ∧ (∃ g, Q i g (Fin.cons x (Fin.tail v)) ∧ g.val = truth) ∧ |
| T i y (Fin.cons x (Fin.tail v))) := by |
| have hQtotal := hQ.reindex (Fin.cons 1 (Fin.cons 2 (fun j => j.succ.succ.succ.succ.succ)) : Fin (k+2) → Fin (k+5)) |
| have hTtotal := hT.reindex (Fin.cons 0 (Fin.cons 2 (fun j => j.succ.succ.succ.succ.succ)) : Fin (k+2) → Fin (k+5)) |
| have htotal := ((hmem.reindex (![0,1] : Fin 2 → Fin (k+3))).imp |
| (((hQtotal.and hTtotal).ex (by omega)).ex (by omega))).all (by omega) |
| have hQmember := hQ.reindex (Fin.cons 0 (Fin.cons 1 (fun j => j.succ.succ.succ.succ.succ)) : Fin (k+2) → Fin (k+5)) |
| have hgtruth := htruth.reindex (![0] : Fin 1 → Fin (k+5)) |
| have hguard := (hQmember.and hgtruth).ex (by omega) |
| have hTmember := hT.reindex (Fin.cons 1 (Fin.cons 0 (fun j => j.succ.succ.succ.succ)) : Fin (k+2) → Fin (k+4)) |
| have hrhs := ((hmem.reindex (![0,2] : Fin 2 → Fin (k+4))).and (hguard.and hTmember)).ex (by omega) |
| have hext := ((hmem.reindex (![0,2] : Fin 2 → Fin (k+3))).iff hrhs).all (by omega) |
| have hbound := hP.reindex (Fin.cons 0 (fun j => j.succ.succ) : Fin (k+1) → Fin (k+2)) |
| have hset' := hset.reindex (![1] : Fin 1 → Fin (k+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 |
|
|
| end CPTSeparation.Operational |
|
|
| namespace CPTSeparation.Operational.Term |
|
|
| open Classical Hereditary Counting HFCoding Finset |
|
|
| local instance {A : Type*} : DecidableEq (HF A) := Classical.decEq _ |
|
|
| variable {R F : Type} {arity : F → ℕ} |
|
|
| def width : {k : ℕ} → Term R F arity k → ℕ |
| | k,.var _ | k,.constant _ | k,.atoms => k+6 |
| | k,.app f args => k+6+arity f+∑ j, width (args j) |
| | k,.pair a b | k,.equal a b | k,.member a b | k,.input _ a b | k,.and a b => k+6+width a+width b |
| | k,.union a | k,.unique a | k,.card a | k,.isAtom a | k,.not a => k+6+width a |
| | k,.conditional c a b => k+6+width c+width a+width b |
| | k,.comprehension a b c => k+6+width a+width b+width c |
|
|
| variable {ι L : Type} {A : ι → Type} [∀ i, Fintype (A i)] |
|
|
| variable (d : ∀ i, Set (HF (A i))) (S : ∀ i, Counting.Structure L (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 S m 2 (fun _ v => (v 0).val ∈ (v 1).val)) |
|
|
| variable (hset : UniformDefinable S m 1 (fun _ v => isSet (v 0).val = true)) |
|
|
| variable (rel : ∀ i, R → A i → A i → Bool) (s : ∀ i, State F arity (A i)) |
|
|
| variable (hinput : ∀ r, UniformDefinable S m 2 (fun i v => inputRelation (rel i) r (v 0).val (v 1).val)) |
|
|
| variable (hstate : ∀ f, UniformDefinable S m (arity f+1) |
| (fun i v => (v 0).val = (s i).value ⟨f,fun j => (v j.succ).val⟩)) |
|
|
| include hd hp ha hmem hset hinput hstate in |
| lemma uniform_graph (K : ℕ) {k : ℕ} (t : Term R F arity k) (hm : t.width ≤ m) : |
| UniformDefinable S m (k+1) (fun i v => Graph (d i) K (rel i) (s i) t (v 0) (Fin.tail v)) := by |
| induction t with |
| | var j => exact UniformDefinable.equal 0 j.succ |
| | constant n => |
| simp only [width] at hm |
| exact (HFCoding.uniform_ordinal S hmem hset (by omega) hd hp n).reindex ![0] |
| | atoms => |
| simp only [width] at hm |
| exact (uniform_atoms d S hd ha hmem hset (by omega)).reindex ![0] |
| | @app k f args ih => |
| simp only [width] at hm |
| have hh (j) := (single_le_sum (fun j (_ : j ∈ (univ : Finset (Fin (arity f)))) => Nat.zero_le (width (args j))) (mem_univ j)) |
| have hh' := UniformDefinable.compose_vec (fun j => ih j (by have := hh j; omega)) (hstate f) (by omega) |
| simpa only [Graph,Fin.cons_zero,Fin.tail_cons,Fin.cons_succ] using hh' |
| | pair a b iha ihb => |
| simp only [width] at hm |
| have hh := UniformDefinable.compose_binary (iha (by omega)) (ihb (by omega)) |
| (uniform_double_value d S hd hmem hset (by omega)) (by omega) |
| apply hh.congr |
| intro i v |
| simp only [Graph,Fin.cons_zero,Fin.tail_cons] |
| rfl |
| | union a ih => |
| simp only [width] at hm |
| have hh := UniformDefinable.compose_unary (ih (by omega)) (uniform_union d S hd hmem hset (by omega)) (by omega) |
| apply hh.congr |
| intro i v |
| simp only [Graph,Fin.cons_zero,Fin.tail_cons] |
| rfl |
| | unique a ih => |
| simp only [width] at hm |
| have hh := UniformDefinable.compose_unary (ih (by omega)) (uniform_unique d S hd hp hmem hset (by omega)) (by omega) |
| apply hh.congr |
| intro i v |
| simp only [Graph,Fin.cons_zero,Fin.tail_cons] |
| rfl |
| | card a ih => |
| simp only [width] at hm |
| have hh := UniformDefinable.compose_unary (ih (by omega)) (uniform_card d S hd hp hmem hset (by omega) K) (by omega) |
| apply hh.congr |
| intro i v |
| simp only [Graph,BoundedCard,Fin.cons_zero,Fin.tail_cons] |
| rfl |
| | equal a b iha ihb => |
| simp only [width] at hm |
| have htest : UniformDefinable S m 3 (fun _ v => (v 1).val = (v 2).val) := |
| (UniformDefinable.equal 1 2).congr (fun _ _ => Subtype.ext_iff) |
| have hbool := uniform_boolean d S hd hp hmem hset (by omega) htest |
| have hh := UniformDefinable.compose_binary (iha (by omega)) (ihb (by omega)) hbool (by omega) |
| apply hh.congr |
| intro i v |
| simp only [Graph,Fin.cons_zero,Fin.tail_cons] |
| rfl |
| | member a b iha ihb => |
| simp only [width] at hm |
| have hbool := uniform_boolean d S hd hp hmem hset (by omega) (hmem.reindex (![1,2] : Fin 2 → Fin 3)) |
| have hh := UniformDefinable.compose_binary (iha (by omega)) (ihb (by omega)) hbool (by omega) |
| apply hh.congr |
| intro i v |
| simp only [Graph,Fin.cons_zero,Fin.tail_cons] |
| rfl |
| | isAtom a ih => |
| simp only [width] at hm |
| have htest : UniformDefinable S m 2 (fun _ v => isSet (v 1).val = false) := by |
| apply (hset.reindex (![1] : Fin 1 → Fin 2)).neg.congr |
| intro i v; dsimp; cases isSet (v 1).val <;> simp |
| have hbool := uniform_boolean d S hd hp hmem hset (by omega) htest |
| have hh := UniformDefinable.compose_unary (ih (by omega)) hbool (by omega) |
| apply hh.congr |
| intro i v |
| simp only [Graph,Fin.cons_zero,Fin.tail_cons] |
| rfl |
| | input r a b iha ihb => |
| simp only [width] at hm |
| have hbool := uniform_boolean d S hd hp hmem hset (by omega) ((hinput r).reindex (![1,2] : Fin 2 → Fin 3)) |
| have hh := UniformDefinable.compose_binary (iha (by omega)) (ihb (by omega)) hbool (by omega) |
| apply hh.congr |
| intro i v |
| simp only [Graph,Fin.cons_zero,Fin.tail_cons] |
| rfl |
| | not a ih => |
| simp only [width] at hm |
| have ht := (HFCoding.uniform_ordinal S hmem hset (by omega) hd hp 1).reindex (![1] : Fin 1 → Fin 2) |
| have hbool := uniform_boolean d S hd hp hmem hset (by omega) ht.neg |
| have hh := UniformDefinable.compose_unary (ih (by omega)) hbool (by omega) |
| apply hh.congr |
| intro i v |
| simp only [Graph,Fin.cons_zero,Fin.tail_cons] |
| rfl |
| | and a b iha ihb => |
| simp only [width] at hm |
| have ht := HFCoding.uniform_ordinal S hmem hset (by omega) hd hp 1 |
| have hpred := (ht.reindex (![1] : Fin 1 → Fin 3)).and (ht.reindex (![2] : Fin 1 → Fin 3)) |
| have hbool := uniform_boolean d S hd hp hmem hset (by omega) hpred |
| have hh := UniformDefinable.compose_binary (iha (by omega)) (ihb (by omega)) hbool (by omega) |
| apply hh.congr |
| intro i v |
| simp only [Graph,Fin.cons_zero,Fin.tail_cons] |
| rfl |
| | @conditional k c a b ihc iha ihb => |
| simp only [width] at hm |
| have h0 := (ihc (by omega)).reindex (Fin.cons 0 (fun j => j.succ.succ) : Fin (k+1) → Fin (k+2)) |
| have h1 := (iha (by omega)).reindex (Fin.succ : Fin (k+1) → Fin (k+2)) |
| have h2 := (ihb (by omega)).reindex (Fin.succ : Fin (k+1) → Fin (k+2)) |
| have ht := (HFCoding.uniform_ordinal S hmem hset (by omega) hd hp 1).reindex (![0] : Fin 1 → Fin (k+2)) |
| apply ((h0.and ((ht.and h1).or (ht.neg.and h2))).ex (by omega)).congr |
| intro i v |
| simp only [Graph,Fin.cons_zero,Fin.cons_succ,Function.comp_def] |
| rfl |
| | comprehension bound guard body ihb ihg ihy => |
| simp only [width] at hm |
| exact uniform_comprehension d S hmem hset (HFCoding.uniform_ordinal S hmem hset (by omega) hd hp 1) |
| (ihb (by omega)) (ihg (by omega)) (ihy (by omega)) (by omega) |
|
|
| end CPTSeparation.Operational.Term |
|
|
| namespace CPTSeparation.Operational.Rule |
|
|
| section |
|
|
| open Classical Hereditary Finset |
|
|
| variable {A R F : Type} {arity : F → ℕ} [Fintype A] |
|
|
| local instance {C : Type} : DecidableEq (HF C) := Classical.decEq _ |
|
|
| def trace (rel : R → A → A → Bool) (s : State F arity A) : |
| {k : ℕ} → Rule R F arity k → (Fin k → HF A) → Finset (HF A) |
| | _,.skip,_ => ∅ |
| | _,.update _ args value,v => value.trace rel s v ∪ univ.biUnion (fun j => (args j).trace rel s v) |
| | _,.parallel a b,v => trace rel s a v ∪ trace rel s b v |
| | _,.conditional c a b,v => c.trace rel s v ∪ trace rel s a v ∪ trace rel s b v |
| | _,.forall b r,v => b.trace rel s v ∪ (elements (b.eval rel s v)).biUnion (fun x => trace rel s r (Fin.cons x v)) |
| | _,.letValue b r,v => b.trace rel s v ∪ trace rel s r (Fin.cons (b.eval rel s v) v) |
|
|
| def bound : {k : ℕ} → Rule R F arity k → Polynomial ℕ |
| | _,.skip => 0 |
| | _,.update _ args value => value.bound + ∑ j, (args j).bound |
| | _,.parallel a b => bound a + bound b |
| | _,.conditional c a b => c.bound + bound a + bound b |
| | _,.forall b r => b.bound + b.bound * (bound r).comp (.X + b.bound) |
| | _,.letValue b r => b.bound + (bound r).comp (.X + b.bound) |
|
|
| lemma closure_update_subset_trace (rel : R → A → A → Bool) (s : State F arity A) |
| {k : ℕ} (r : Rule R F arity k) (v : Fin k → HF A) |
| {l : Location F arity A} {z : HF A} (hu : (l,z) ∈ r.updates rel s v) : |
| closure z ⊆ r.trace rel s v ∧ ∀ j, closure (l.2 j) ⊆ r.trace rel s v := by |
| induction r generalizing l z with |
| | skip => simp [updates] at hu |
| | update f args value => |
| have he := mem_singleton.mp hu |
| cases he |
| refine ⟨(Term.closure_eval_subset_trace rel s value v).trans subset_union_left,?_⟩ |
| intro j x hx |
| exact mem_union_right _ (mem_biUnion.mpr ⟨j,mem_univ _,Term.closure_eval_subset_trace rel s (args j) v hx⟩) |
| | parallel a b ia ib => |
| rcases mem_union.mp hu with ha | hb |
| · obtain ⟨hz,hl⟩ := ia v ha |
| exact ⟨hz.trans subset_union_left, fun j => (hl j).trans subset_union_left⟩ |
| · obtain ⟨hz,hl⟩ := ib v hb |
| exact ⟨hz.trans subset_union_right, fun j => (hl j).trans subset_union_right⟩ |
| | conditional c a b ia ib => |
| unfold updates at hu |
| split at hu |
| · obtain ⟨hz,hl⟩ := ia v hu |
| have hs : a.trace rel s v ⊆ (conditional c a b).trace rel s v := |
| subset_union_right.trans subset_union_left |
| exact ⟨hz.trans hs,fun j => (hl j).trans hs⟩ |
| · obtain ⟨hz,hl⟩ := ib v hu |
| exact ⟨hz.trans subset_union_right,fun j => (hl j).trans subset_union_right⟩ |
| | «forall» b r ih => |
| obtain ⟨x,hx,hu⟩ := mem_biUnion.mp hu |
| obtain ⟨hz,hl⟩ := ih _ hu |
| have hs : r.trace rel s (Fin.cons x v) ⊆ (Rule.forall b r).trace rel s v := by |
| intro y hy; exact mem_union_right _ (mem_biUnion.mpr ⟨x,hx,hy⟩) |
| exact ⟨hz.trans hs,fun j => (hl j).trans hs⟩ |
| | letValue b r ih => |
| obtain ⟨hz,hl⟩ := ih _ hu |
| exact ⟨hz.trans subset_union_right,fun j => (hl j).trans subset_union_right⟩ |
|
|
| lemma card_trace_le (rel : R → A → A → Bool) (s : State F arity A) |
| {k : ℕ} (r : Rule R F arity k) (v : Fin k → HF A) (K : ℕ) (hK : Term.potential s v ≤ K) : |
| (r.trace rel s v).card ≤ r.bound.eval K := by |
| induction r generalizing K with |
| | skip => simp [trace,bound] |
| | update f args value => |
| have hu := (card_union_le (value.trace rel s v) (univ.biUnion (fun j => (args j).trace rel s v))).trans |
| (add_le_add (Term.card_trace_le rel s value v K hK) |
| (card_biUnion_le.trans (sum_le_sum (fun j hj => Term.card_trace_le rel s (args j) v K hK)))) |
| simpa only [trace,bound,Polynomial.eval_add,Polynomial.eval_finsetSum] using hu |
| | parallel a b ia ib => |
| exact (card_union_le _ _).trans (by simpa only [bound,Polynomial.eval_add] using add_le_add (ia v K hK) (ib v K hK)) |
| | conditional c a b ia ib => |
| exact (card_union_le _ _).trans ((add_le_add (card_union_le _ _) (le_refl _)).trans (by |
| simpa only [bound,Polynomial.eval_add] using add_le_add (add_le_add (Term.card_trace_le rel s c v K hK) (ia v K hK)) (ib v K hK))) |
| | «forall» b r ih => |
| have hb := Term.card_trace_le rel s b v K hK |
| have hc := (card_le_card ((elements_subset_closure (b.eval rel s v)).trans (Term.closure_eval_subset_trace rel s b v))).trans hb |
| have he (x) (hx : x ∈ elements (b.eval rel s v)) : Term.potential s (Fin.cons x v) ≤ K+b.bound.eval K := by |
| rw [Term.potential_cons] |
| exact add_le_add hK ((card_le_card ((closure_member_subset hx).trans (Term.closure_eval_subset_trace rel s b v))).trans hb) |
| have hs : ((elements (b.eval rel s v)).biUnion (fun x => r.trace rel s (Fin.cons x v))).card ≤ |
| b.bound.eval K * r.bound.eval (K+b.bound.eval K) := by |
| apply card_biUnion_le.trans |
| calc |
| _ ≤ ∑ _x ∈ elements (b.eval rel s v), r.bound.eval (K+b.bound.eval K) := sum_le_sum (fun x hx => ih _ _ (he x hx)) |
| _ = (elements (b.eval rel s v)).card * r.bound.eval (K+b.bound.eval K) := by simp |
| _ ≤ _ := Nat.mul_le_mul_right _ hc |
| exact (card_union_le _ _).trans (by simpa only [bound,Polynomial.eval_add,Polynomial.eval_mul,Polynomial.eval_comp,Polynomial.eval_X] using add_le_add hb hs) |
| | letValue b r ih => |
| have hb := Term.card_trace_le rel s b v K hK |
| have he : Term.potential s (Fin.cons (b.eval rel s v) v) ≤ K+b.bound.eval K := by |
| rw [Term.potential_cons] |
| exact add_le_add hK ((card_le_card (Term.closure_eval_subset_trace rel s b v)).trans hb) |
| exact (card_union_le _ _).trans (by simpa only [bound,Polynomial.eval_add,Polynomial.eval_comp,Polynomial.eval_X] using add_le_add hb (ih _ _ he)) |
|
|
| end |
|
|
| section |
|
|
| open Classical Hereditary Counting HFCoding Finset |
|
|
| variable {A R F : Type} {arity : F → ℕ} [Fintype A] |
|
|
| local instance {C : Type} : DecidableEq (HF C) := Classical.decEq _ |
|
|
| def Graph (d : Set (HF A)) (K : ℕ) (rel : R → A → A → Bool) (s : State F arity A) : |
| {k : ℕ} → Rule R F arity k → (f : F) → Domain d → (Fin (arity f) → Domain d) → (Fin k → Domain d) → Prop |
| | _,.skip,_,_,_,_ => False |
| | _,.update g args value,f,z,a,v => if h : g = f then |
| Term.Graph d K rel s value z v ∧ ∀ j, Term.Graph d K rel s (args j) (a (Fin.cast (congrArg arity h) j)) v else False |
| | _,.parallel r t,f,z,a,v => Graph d K rel s r f z a v ∨ Graph d K rel s t f z a v |
| | _,.conditional c r t,f,z,a,v => ∃ b, Term.Graph d K rel s c b v ∧ |
| ((b.val = truth ∧ Graph d K rel s r f z a v) ∨ (b.val ≠ truth ∧ Graph d K rel s t f z a v)) |
| | _,.forall b r,f,z,a,v => ∃ w x, Term.Graph d K rel s b w v ∧ x.val ∈ w.val ∧ Graph d K rel s r f z a (Fin.cons x v) |
| | _,.letValue b r,f,z,a,v => ∃ w, Term.Graph d K rel s b w v ∧ Graph d K rel s r f z a (Fin.cons w v) |
|
|
| variable (d : Set (HF A)) (K : ℕ) (rel : R → A → A → Bool) (s : State F arity A) |
|
|
| variable (hd : ∀ x ∈ d, ∀ y, y ∈ x → y ∈ d) |
|
|
| include hd in |
| lemma graph_sound {k : ℕ} (r : Rule R F arity k) (f : F) (z : Domain d) |
| (a : Fin (arity f) → Domain d) (v : Fin k → Domain d) |
| (h : Graph d K rel s r f z a v) : |
| (⟨f,fun j => (a j).val⟩,z.val) ∈ r.updates rel s (fun j => (v j).val) := by |
| induction r generalizing f z a with |
| | skip => exact h.elim |
| | update g args value => |
| unfold Graph at h |
| split at h |
| next he => |
| subst g |
| obtain ⟨hz,ha⟩ := h |
| have hv := Term.graph_sound d K rel s hd value z v hz |
| have ha' : (fun j => (a j).val) = fun j => (args j).eval rel s (fun j => (v j).val) := |
| funext (fun j => Term.graph_sound d K rel s hd (args j) (a j) v (ha j)) |
| simp only [updates,Finset.mem_singleton,hv,ha'] |
| next he => exact h.elim |
| | parallel r t ir it => exact h.elim (fun h => mem_union_left _ (ir _ _ _ _ h)) (fun h => mem_union_right _ (it _ _ _ _ h)) |
| | conditional c r t ir it => |
| obtain ⟨b,hb,h⟩ := h |
| have he := Term.graph_sound d K rel s hd c b v hb |
| rcases h with ⟨hc,hr⟩ | ⟨hc,ht⟩ |
| · simpa only [updates,← he,ite_eq_left hc] using ir _ _ _ _ hr |
| · simpa only [updates,← he,ite_eq_right hc] using it _ _ _ _ ht |
| | @«forall» k b r ih => |
| obtain ⟨w,x,hw,hx,hr⟩ := h |
| have he := Term.graph_sound d K rel s hd b w v hw |
| refine mem_biUnion.mpr ⟨x.val,by rwa [← he],?_⟩ |
| have hv : (fun j => ((Fin.cons x v : Fin (k+1) → Domain d) j).val) = Fin.cons x.val (fun j => (v j).val) := by |
| funext j; refine Fin.cases rfl (fun _ => rfl) j |
| simpa only [hv] using ih f z a (Fin.cons x v) hr |
| | @letValue k b r ih => |
| obtain ⟨w,hw,hr⟩ := h |
| have he := Term.graph_sound d K rel s hd b w v hw |
| have hv : (fun j => ((Fin.cons w v : Fin (k+1) → Domain d) j).val) = Fin.cons w.val (fun j => (v j).val) := by |
| funext j; refine Fin.cases rfl (fun _ => rfl) j |
| simpa only [updates,hv,he] using ih f z a (Fin.cons w v) hr |
|
|
| include hd in |
| lemma graph_complete {k : ℕ} (r : Rule R F arity k) (f : F) (z : Domain d) |
| (a : Fin (arity f) → Domain d) (v : Fin k → Domain d) |
| (ht : ∀ x ∈ r.trace rel s (fun j => (v j).val), x ∈ d ∧ (elements x).card ≤ K) |
| (hu : (⟨f,fun j => (a j).val⟩,z.val) ∈ r.updates rel s (fun j => (v j).val)) : |
| Graph d K rel s r f z a v := by |
| have witness {k} (t : Term R F arity k) (v : Fin k → Domain d) |
| (ht : ∀ x ∈ t.trace rel s (fun j => (v j).val), x ∈ d ∧ (elements x).card ≤ K) := |
| Term.graph_complete d K rel s hd t v ht |
| have hv {k} (x : Domain d) (v : Fin k → Domain d) : |
| (fun j => ((Fin.cons x v : Fin (k+1) → Domain d) j).val) = Fin.cons x.val (fun j => (v j).val) := by |
| funext j; refine Fin.cases rfl (fun _ => rfl) j |
| induction r generalizing f z a with |
| | skip => simp [updates] at hu |
| | update g args value => |
| have he := Finset.mem_singleton.mp hu |
| have hfg : f = g := congrArg (fun p => p.1.1) he |
| subst g |
| have haz := (Prod.mk.inj he) |
| have ha : (fun j => (a j).val) = fun j => (args j).eval rel s (fun j => (v j).val) := by |
| exact eq_of_heq (Sigma.mk.inj_iff.mp haz.1).2 |
| simp only [Graph,Fin.cast_refl,id_eq] |
| constructor |
| · obtain ⟨w,hw,hew⟩ := witness value v (fun x hx => ht x (mem_union_left _ hx)) |
| have hew' : w = z := Subtype.ext (hew.trans haz.2.symm) |
| rwa [← hew'] |
| · intro j |
| obtain ⟨w,hw,hew⟩ := witness (args j) v (fun x hx => ht x (mem_union_right _ (mem_biUnion.mpr ⟨j,mem_univ _,hx⟩))) |
| have hew' : w = a j := Subtype.ext (hew.trans (congrFun ha j).symm) |
| rwa [← hew'] |
| | parallel r t ir it => |
| rcases mem_union.mp hu with h | h |
| · exact Or.inl (ir _ _ _ _ (fun x hx => ht x (mem_union_left _ hx)) h) |
| · exact Or.inr (it _ _ _ _ (fun x hx => ht x (mem_union_right _ hx)) h) |
| | conditional c r t ir it => |
| obtain ⟨b,hb,he⟩ := witness c v (fun x hx => ht x (mem_union_left _ (mem_union_left _ hx))) |
| refine ⟨b,hb,?_⟩ |
| by_cases hc : b.val = truth |
| · left; refine ⟨hc,ir _ _ _ _ (fun x hx => ht x (mem_union_left _ (mem_union_right _ hx))) ?_⟩ |
| simpa only [updates,← he,ite_eq_left hc] using hu |
| · right; refine ⟨hc,it _ _ _ _ (fun x hx => ht x (mem_union_right _ hx)) ?_⟩ |
| simpa only [updates,← he,ite_eq_right hc] using hu |
| | @«forall» k b r ih => |
| obtain ⟨w,hw,he⟩ := witness b v (fun x hx => ht x (mem_union_left _ hx)) |
| obtain ⟨x,hx,hu⟩ := mem_biUnion.mp hu |
| have hxd : x ∈ d := hd _ w.property _ (by rwa [he]) |
| let xx : Domain d := ⟨x,hxd⟩ |
| refine ⟨w,xx,hw,by change x ∈ w.val; rwa [he],ih _ _ _ (Fin.cons xx v) ?_ ?_⟩ |
| · intro y hy |
| rw [hv] at hy |
| exact ht y (mem_union_right _ (mem_biUnion.mpr ⟨x,hx,hy⟩)) |
| · simpa only [hv] using hu |
| | @letValue k b r ih => |
| obtain ⟨w,hw,he⟩ := witness b v (fun x hx => ht x (mem_union_left _ hx)) |
| refine ⟨w,hw,ih _ _ _ (Fin.cons w v) ?_ ?_⟩ |
| · intro x hx |
| rw [hv,he] at hx; exact ht x (mem_union_right _ hx) |
| · simpa only [updates,hv,he] using hu |
|
|
| end |
|
|
| open Classical Hereditary Counting HFCoding Finset |
|
|
| variable {R F : Type} {arity : F → ℕ} |
|
|
| def width : {k : ℕ} → Rule R F arity k → ℕ |
| | _,.skip => 6 |
| | _,.update _ args value => 6+value.width+∑ j, (args j).width |
| | _,.parallel r t => 6+width r+width t |
| | _,.conditional c r t => 6+c.width+width r+width t |
| | _,.forall b r | _,.letValue b r => 6+b.width+width r |
|
|
| variable {ι L : Type} {A : ι → Type} [∀ i, Fintype (A i)] |
|
|
| variable (d : ∀ i, Set (HF (A i))) (S : ∀ i, Counting.Structure L (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 S m 2 (fun _ v => (v 0).val ∈ (v 1).val)) |
|
|
| variable (hset : UniformDefinable S m 1 (fun _ v => isSet (v 0).val = true)) |
|
|
| variable (rel : ∀ i, R → A i → A i → Bool) (s : ∀ i, State F arity (A i)) |
|
|
| variable (hinput : ∀ r, UniformDefinable S m 2 (fun i v => inputRelation (rel i) r (v 0).val (v 1).val)) |
|
|
| variable (hstate : ∀ f, UniformDefinable S m (arity f+1) |
| (fun i v => (v 0).val = (s i).value ⟨f,fun j => (v j.succ).val⟩)) |
|
|
| include hd hp ha hmem hset hinput hstate in |
| lemma uniform_graph (K : ℕ) {k n : ℕ} (r : Rule R F arity k) (f : F) |
| (z : Fin n) (a : Fin (arity f) → Fin n) (v : Fin k → Fin n) (hm : n+r.width ≤ m) : |
| UniformDefinable S m n (fun i w => Graph (d i) K (rel i) (s i) r f (w z) (w ∘ a) (w ∘ v)) := by |
| have term {k n : ℕ} (t : Term R F arity k) (z : Fin n) (v : Fin k → Fin n) (ht : t.width ≤ m) : |
| UniformDefinable S m n (fun i w => Term.Graph (d i) K (rel i) (s i) t (w z) (w ∘ v)) := by |
| apply (Term.uniform_graph d S hd hp ha hmem hset rel s hinput hstate K t ht |>.reindex (Fin.cons z v)).congr |
| intro i w |
| simp only [Fin.comp_cons,Fin.cons_zero,Fin.tail_cons] |
| induction r generalizing n with |
| | skip => exact UniformDefinable.falsum |
| | update g args value => |
| simp only [width] at hm |
| by_cases h : g = f |
| · subst g |
| have hv := term value z v (by omega) |
| have hag (j) := single_le_sum (fun j (_ : j ∈ (univ : Finset (Fin (arity f)))) => Nat.zero_le (Term.width (args j))) (mem_univ j) |
| have has := UniformDefinable.forall_finite (fun j => term (args j) (a j) v (by have := hag j; omega)) |
| apply (hv.and has).congr |
| intro i w |
| simp [Graph] |
| · apply UniformDefinable.falsum.congr |
| intro i w; simp only [Graph,dite_eq_right h] |
| | parallel r t ir it => |
| simp only [width] at hm |
| exact (ir z a v (by omega)).or (it z a v (by omega)) |
| | @conditional k c r t ir it => |
| simp only [width] at hm |
| let vv : Fin k → Fin (n+1) := Fin.succ ∘ v |
| have hc := term c (0 : Fin (n+1)) vv (by omega) |
| have hr := ir z.succ (Fin.succ ∘ a) vv (by omega) |
| have ht := it z.succ (Fin.succ ∘ a) vv (by omega) |
| have hb := (HFCoding.uniform_ordinal S hmem hset (by omega) hd hp 1).reindex (![0] : Fin 1 → Fin (n+1)) |
| apply ((hc.and ((hb.and hr).or (hb.neg.and ht))).ex (by omega)).congr |
| intro i w |
| simp only [Graph,vv,Fin.cons_zero,Fin.cons_succ,Function.comp_apply] |
| rfl |
| | @«forall» k b r ih => |
| simp only [width] at hm |
| let vv : Fin k → Fin (n+2) := fun j => (v j).succ.succ |
| have hb := term b (1 : Fin (n+2)) vv (by omega) |
| have hx := hmem.reindex (![0,1] : Fin 2 → Fin (n+2)) |
| have hr := ih z.succ.succ (fun j => (a j).succ.succ) (Fin.cons 0 vv) (by omega) |
| apply (((hb.and (hx.and hr)).ex (by omega)).ex (by omega)).congr |
| intro i w |
| change (∃ b' x, _ ∧ _ ∧ _) ↔ _ |
| simp only [Graph,vv,Fin.comp_cons,Fin.cons_zero,Fin.cons_succ,Function.comp_apply] |
| rfl |
| | @letValue k b r ih => |
| simp only [width] at hm |
| let vv : Fin k → Fin (n+1) := Fin.succ ∘ v |
| have hb := term b (0 : Fin (n+1)) vv (by omega) |
| have hr := ih z.succ (Fin.succ ∘ a) (Fin.cons 0 vv) (by omega) |
| apply ((hb.and hr).ex (by omega)).congr |
| intro i w |
| simp only [Graph,vv,Fin.comp_cons,Fin.cons_zero,Fin.cons_succ] |
| rfl |
| |
| end CPTSeparation.Operational.Rule |
| |
| end |
| |
| end OAI |
| |
