Download data/lean/OAI/ModelTheory/Choiceless/Definability.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 53.3 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/ModelTheory/Choiceless/Definability.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/ModelTheory/Choiceless/Definability.lean
-
curl -L -o Definability.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/ModelTheory/Choiceless/Definability.lean
53.3 kB
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) // y.val ∈ x.val} ≃ Fin n) ↔ (elements x.val).card = n := by
let e : {y : Domain (d i) // y.val ∈ x.val} ≃ {y // y ∈ elements x.val} :=
{ 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 // y ∈ elements x.val}).trans (finCongr (by simpa using h))
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
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) // y.val ∈ x.val} ≃ Fin n) ↔ (elements x.val).card = n := by
let e : {y : Domain (d i) // y.val ∈ x.val} ≃ {y // y ∈ elements x.val} :=
{ 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 // y ∈ elements x.val}).trans (finCongr (by simpa using h))
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]