Download data/lean/OAI/Computability/WitnessedChoice/CountingTransfer.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 43.2 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/WitnessedChoice/CountingTransfer.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Computability/WitnessedChoice/CountingTransfer.lean
-
curl -L -o CountingTransfer.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/WitnessedChoice/CountingTransfer.lean
43.2 kB
import OAI.Computability.WitnessedChoice.FormTransfer
namespace OAI
namespace WitnessedSeparation.HFCoding
noncomputable section
open Classical Finset Hereditary Counting
variable {A R : Type} {d : Set (HF A)}
abbrev Domain (d : Set (HF A)) := {x : HF A // x ∈ d}
variable (hd : ∀ x ∈ d, ∀ y, y ∈ x → y ∈ d)
variable (S : Counting.Structure R (Domain d)) {m : ℕ}
def SingletonTest (u a : Domain d) : Prop :=
isSet u.val = true ∧ ∀ w : Domain d, w.val ∈ u.val ↔ w = a
def DoubleTest (u a b : Domain d) : Prop :=
isSet u.val = true ∧ ∀ w : Domain d, w.val ∈ u.val ↔ w = a ∨ w = b
include hd
theorem singletonTest_iff (u a : Domain d) : SingletonTest u a ↔ u.val = Hereditary.singleton a.val := by
constructor
· rintro ⟨hu,h⟩
apply ext_sets hu (isSet_ofFinset _)
intro w
change w ∈ u.val ↔ w ∈ Hereditary.singleton a.val
rw [Hereditary.mem_singleton]
constructor
· intro hw
exact congrArg Subtype.val ((h ⟨w,hd _ u.property _ hw⟩).mp hw)
· rintro rfl
exact (h a).mpr rfl
· intro h
constructor
· rw [h]; exact isSet_ofFinset _
· intro w
rw [h,Hereditary.mem_singleton]
exact Subtype.val_injective.eq_iff
theorem doubleTest_iff (u a b : Domain d) : DoubleTest u a b ↔ u.val = double a.val b.val := by
constructor
· rintro ⟨hu,h⟩
apply ext_sets hu (isSet_ofFinset _)
intro w
change w ∈ u.val ↔ w ∈ double a.val b.val
rw [mem_double]
constructor
· intro hw
rcases (h ⟨w,hd _ u.property _ hw⟩).mp hw with h|h
· exact Or.inl (congrArg Subtype.val h)
· exact Or.inr (congrArg Subtype.val h)
· rintro (rfl|rfl)
· exact (h a).mpr (Or.inl rfl)
· exact (h b).mpr (Or.inr rfl)
· intro h
constructor
· rw [h]; exact isSet_ofFinset _
· intro w
rw [h,mem_double]
exact or_congr Subtype.val_injective.eq_iff Subtype.val_injective.eq_iff
def PairTest (z a b : Domain d) : Prop :=
∃ u v : Domain d, SingletonTest u a ∧ DoubleTest v a b ∧ DoubleTest z u v
theorem pairTest_iff (z a b : Domain d) : PairTest z a b ↔ z.val = pair a.val b.val := by
constructor
· rintro ⟨u,v,hu,hv,hz⟩
rw [singletonTest_iff hd] at hu
rw [doubleTest_iff hd] at hv hz
simpa only [hu,hv,pair] using hz
· intro hz
have hu : Hereditary.singleton a.val ∈ d := hd _ z.property _ (by rw [hz]; simp [pair])
have hv : double a.val b.val ∈ d := hd _ z.property _ (by rw [hz]; simp [pair])
refine ⟨⟨Hereditary.singleton a.val,hu⟩,⟨double a.val b.val,hv⟩,?_,?_,?_⟩
· exact (singletonTest_iff hd _ _).mpr rfl
· exact (doubleTest_iff hd _ _ _).mpr rfl
· exact (doubleTest_iff hd _ _ _).mpr hz
variable (hmem : Definable S m 2 (fun v => (v 0).val ∈ (v 1).val))
variable (hset : Definable S m 1 (fun v => isSet (v 0).val = true))
variable (hm : 6 ≤ m)
include hmem hset hm
omit hd in
theorem singleton_definable : Definable S m 2 (fun v => SingletonTest (v 0) (v 1)) := by
have hs : Definable S m 2 (fun v => isSet (v 0).val = true) := by
simpa using hset.reindex (![0] : Fin 1 → Fin 2)
have hbody : Definable S m 3 (fun v => (v 0).val ∈ (v 1).val ↔ v 0 = v 2) := by
have hmem' : Definable S m 3 (fun v => (v 0).val ∈ (v 1).val) := by
simpa using hmem.reindex (![0,1] : Fin 2 → Fin 3)
exact hmem'.iff (Definable.equal 0 2)
exact hs.and (hbody.all (by omega))
omit hd in
theorem double_definable : Definable S m 3 (fun v => DoubleTest (v 0) (v 1) (v 2)) := by
have hs : Definable S m 3 (fun v => isSet (v 0).val = true) := by
simpa using hset.reindex (![0] : Fin 1 → Fin 3)
have hbody : Definable S m 4 (fun v => (v 0).val ∈ (v 1).val ↔ v 0 = v 2 ∨ v 0 = v 3) := by
have hmem' : Definable S m 4 (fun v => (v 0).val ∈ (v 1).val) := by
simpa using hmem.reindex (![0,1] : Fin 2 → Fin 4)
exact hmem'.iff ((Definable.equal 0 2).or (Definable.equal 0 3))
exact hs.and (hbody.all (by omega))
theorem pair_definable : Definable S m 3 (fun v => (v 0).val = pair (v 1).val (v 2).val) := by
have h1 : Definable S m 5 (fun v => SingletonTest (v 1) (v 3)) := by
simpa using (singleton_definable S hmem hset hm).reindex (![1,3] : Fin 2 → Fin 5)
have h2 : Definable S m 5 (fun v => DoubleTest (v 0) (v 3) (v 4)) := by
simpa using (double_definable S hmem hset hm).reindex (![0,3,4] : Fin 3 → Fin 5)
have h3 : Definable S m 5 (fun v => DoubleTest (v 2) (v 1) (v 0)) := by
simpa using (double_definable S hmem hset hm).reindex (![2,1,0] : Fin 3 → Fin 5)
have hp := ((h1.and (h2.and h3)).ex (by omega)).ex (by omega)
apply hp.congr
intro v
exact pairTest_iff hd (v 0) (v 1) (v 2)
theorem ordinal_definable (hpure : ∀ i, ordinal (A := A) i ∈ d) (i : ℕ) :
Definable S m 1 (fun v => (v 0).val = ordinal i) := by
induction i using Nat.strong_induction_on with
| h i ih =>
have hor : Definable S m 2 (fun v => ∃ k ∈ range i, (v 0).val = ordinal k) := by
apply Definable.exists_finset
intro k hk
simpa using (ih k (mem_range.mp hk)).reindex (![0] : Fin 1 → Fin 2)
have hbody := (hmem.iff hor).all (by omega : 1 < m)
apply (hset.and hbody).congr
intro v
change (isSet (v 0).val = true ∧ ∀ w : Domain d,
w.val ∈ (v 0).val ↔ ∃ k ∈ range i, w.val = ordinal k) ↔ _
constructor
· rintro ⟨hv,h⟩
apply ext_sets hv (ordinal_isSet i)
intro w
rw [mem_ordinal]
constructor
· intro hw
obtain ⟨k,hk,hkw⟩ := (h ⟨w,hd _ (v 0).property _ hw⟩).mp hw
exact ⟨k,mem_range.mp hk,hkw⟩
· rintro ⟨k,hk,rfl⟩
exact (h ⟨ordinal k,hpure k⟩).mpr ⟨k,mem_range.mpr hk,rfl⟩
· intro hv
refine ⟨by rw [hv]; exact ordinal_isSet i,?_⟩
intro w
rw [hv,mem_ordinal]
simp only [mem_range]
end
end WitnessedSeparation.HFCoding
namespace WitnessedSeparation.Counting
noncomputable section
open Classical Finset
variable {R ι : Type*} {D : ι → Type*} (S : ∀ i, Structure R (D i)) {m n k : ℕ}
def UniformDefinable (m n : ℕ) (P : ∀ i, (Fin n → D i) → Prop) : Prop :=
∀ args : Fin n → Fin m, ∃ φ : Formula R (Fin m),
φ.free ⊆ univ.image args ∧ ∀ i v, φ.eval (S i) v ↔ P i (v ∘ args)
namespace UniformDefinable
variable {S} {P Q : ∀ i, (Fin n → D i) → Prop}
theorem congr (h : UniformDefinable S m n P) (heq : ∀ i v, P i v ↔ Q i v) :
UniformDefinable S m n Q := by
intro args
obtain ⟨φ,hφ,he⟩ := h args
exact ⟨φ,hφ,fun i v => (he i v).trans (heq _ _)⟩
theorem reindex (h : UniformDefinable S m n P) (f : Fin n → Fin k) :
UniformDefinable S m k (fun i v => P i (v ∘ f)) := by
intro args
obtain ⟨φ,hφ,he⟩ := h (args ∘ f)
refine ⟨φ,?_,fun i v => he i v⟩
intro j hj
obtain ⟨l,_,rfl⟩ := mem_image.mp (hφ hj)
exact mem_image.mpr ⟨f l,mem_univ _,rfl⟩
theorem falsum : UniformDefinable S m n (fun _ _ => False) :=
fun _ => ⟨.falsum,by simp [Formula.free],fun _ _ => Iff.rfl⟩
theorem neg (h : UniformDefinable S m n P) : UniformDefinable S m n (fun i v => ¬ P i v) := by
intro args
obtain ⟨φ,hφ,he⟩ := h args
exact ⟨.neg φ,hφ,fun i v => not_congr (he i v)⟩
theorem and (h : UniformDefinable S m n P) (h' : UniformDefinable S m n Q) :
UniformDefinable S m n (fun i v => P i v ∧ Q i v) := by
intro args
obtain ⟨φ,hφ,he⟩ := h args
obtain ⟨ψ,hψ,he'⟩ := h' args
exact ⟨.and φ ψ,union_subset hφ hψ,fun i v => and_congr (he i v) (he' i v)⟩
theorem or (h : UniformDefinable S m n P) (h' : UniformDefinable S m n Q) :
UniformDefinable S m n (fun i v => P i v ∨ Q i v) :=
(h.neg.and h'.neg).neg.congr (fun _ _ => by tauto)
theorem imp (h : UniformDefinable S m n P) (h' : UniformDefinable S m n Q) :
UniformDefinable S m n (fun i v => P i v → Q i v) :=
(h.neg.or h').congr (fun _ _ => by tauto)
theorem iff (h : UniformDefinable S m n P) (h' : UniformDefinable S m n Q) :
UniformDefinable S m n (fun i v => P i v ↔ Q i v) :=
((h.imp h').and (h'.imp h)).congr (fun _ _ => by tauto)
theorem equal (a b : Fin n) : UniformDefinable S m n (fun _ v => v a = v b) := by
intro args
refine ⟨.equal (args a) (args b),?_,fun _ _ => Iff.rfl⟩
simp only [Formula.free,insert_subset_iff,singleton_subset_iff]
exact ⟨mem_image.mpr ⟨a,mem_univ _,rfl⟩,mem_image.mpr ⟨b,mem_univ _,rfl⟩⟩
theorem relation (r : R) (a b : Fin n) :
UniformDefinable S m n (fun i v => (S i).rel r (v a) (v b)) := by
intro args
refine ⟨.relation r (args a) (args b),?_,fun _ _ => Iff.rfl⟩
simp only [Formula.free,insert_subset_iff,singleton_subset_iff]
exact ⟨mem_image.mpr ⟨a,mem_univ _,rfl⟩,mem_image.mpr ⟨b,mem_univ _,rfl⟩⟩
private theorem fresh (args : Fin n → Fin m) (hn : n < m) : ∃ i, ∀ j, args j ≠ i := by
have hns : ¬ Function.Surjective args := by
intro hs
have h := Fintype.card_le_of_surjective args hs
simp only [Fintype.card_fin] at h
omega
simp only [Function.Surjective] at hns
push Not at hns
exact hns
private theorem updated_args {X : Type*} (args : Fin n → Fin m) (i : Fin m)
(hi : ∀ j, args j ≠ i) (v : Fin m → X) (x : X) :
Function.update v i x ∘ Fin.cons i args = Fin.cons x (v ∘ args) := by
funext j
refine Fin.cases ?_ (fun j => ?_) j
· simp
· simp [hi j]
private theorem free_binder {args : Fin n → Fin m} {i : Fin m} {φ : Formula R (Fin m)}
(hφ : φ.free ⊆ univ.image (Fin.cons i args)) : φ.free.erase i ⊆ univ.image args := by
intro j hj
obtain ⟨k,_,hk⟩ := mem_image.mp (hφ (mem_erase.mp hj).2)
cases k using Fin.cases with
| zero =>
simp only [Fin.cons_zero] at hk
exact False.elim ((mem_erase.mp hj).1 hk.symm)
| succ k => exact mem_image.mpr ⟨k,mem_univ _,hk⟩
theorem ex {P : ∀ i, (Fin (n+1) → D i) → Prop} (h : UniformDefinable S m (n+1) P) (hn : n < m) :
UniformDefinable S m n (fun i v => ∃ x, P i (Fin.cons x v)) := by
intro args
obtain ⟨a,ha⟩ := fresh args hn
obtain ⟨φ,hφ,he⟩ := h (Fin.cons a args)
refine ⟨.ex a φ,free_binder hφ,?_⟩
intro i v
apply exists_congr
intro x
simpa only [updated_args args a ha] using he i (Function.update v a x)
theorem all {P : ∀ i, (Fin (n+1) → D i) → Prop} (h : UniformDefinable S m (n+1) P) (hn : n < m) :
UniformDefinable S m n (fun i v => ∀ x, P i (Fin.cons x v)) :=
(h.neg.ex hn).neg.congr (fun _ _ => by simp)
theorem exact {P : ∀ i, (Fin (n+1) → D i) → Prop} (h : UniformDefinable S m (n+1) P) (hn : n < m) (k : ℕ) :
UniformDefinable S m n (fun i v => Nonempty ({x : D i // P i (Fin.cons x v)} ≃ Fin k)) := by
intro args
obtain ⟨a,ha⟩ := fresh args hn
obtain ⟨φ,hφ,he⟩ := h (Fin.cons a args)
refine ⟨.exact a k φ,free_binder hφ,?_⟩
intro i v
let e : {x : D i // φ.eval (S i) (Function.update v a x)} ≃ {x : D i // P i (Fin.cons x (v ∘ args))} :=
Equiv.subtypeEquivRight (fun x => by simpa only [updated_args args a ha] using he i (Function.update v a x))
exact ⟨fun ⟨f⟩ => ⟨e.symm.trans f⟩,fun ⟨f⟩ => ⟨e.trans f⟩⟩
theorem exists_finset {κ : Type*} {P : κ → ∀ i, (Fin n → D i) → Prop} (t : Finset κ)
(h : ∀ a ∈ t, UniformDefinable S m n (P a)) : UniformDefinable S m n (fun i v => ∃ a ∈ t, P a i v) := by
induction t using Finset.induction_on with
| empty => exact (falsum (S := S)).congr (fun _ _ => by simp)
| @insert a t ha ih =>
exact ((h a (mem_insert_self _ _)).or (ih (fun b hb => h b (mem_insert_of_mem hb)))).congr
(fun _ _ => by simp only [mem_insert,exists_eq_or_imp])
theorem bounded_hartig {P Q : ∀ i, (Fin (n+1) → D i) → Prop}
(hP : UniformDefinable S m (n+1) P) (hQ : UniformDefinable S m (n+1) Q) (hn : n < m) (B : ℕ) :
UniformDefinable S m n (fun i v => ∃ k ≤ B,
Nonempty ({x : D i // P i (Fin.cons x v)} ≃ Fin k) ∧
Nonempty ({x : D i // Q i (Fin.cons x v)} ≃ Fin k)) := by
apply (exists_finset (range (B+1)) (fun k _ => (hP.exact hn k).and (hQ.exact hn k))).congr
intro i v
simp only [mem_range,Nat.lt_succ_iff]
end UniformDefinable
end
end WitnessedSeparation.Counting
namespace WitnessedSeparation.HFCoding
noncomputable section
open Classical Finset Hereditary Counting
variable {ι R : Type} {A : ι → Type} {d : ∀ i, Set (HF (A i))}
variable (S : ∀ i, Counting.Structure R (Domain (d i))) {m : ℕ}
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)
include hmem hset hm
theorem uniform_singleton : UniformDefinable S m 2 (fun _ v => SingletonTest (v 0) (v 1)) := by
have hs : UniformDefinable S m 2 (fun _ v => isSet (v 0).val = true) := by
simpa using hset.reindex (![0] : Fin 1 → Fin 2)
have hbody : UniformDefinable S m 3 (fun _ v => (v 0).val ∈ (v 1).val ↔ v 0 = v 2) := by
have hmem' : UniformDefinable S m 3 (fun _ v => (v 0).val ∈ (v 1).val) := by
simpa using hmem.reindex (![0,1] : Fin 2 → Fin 3)
exact hmem'.iff (UniformDefinable.equal 0 2)
exact hs.and (hbody.all (by omega))
theorem uniform_double : UniformDefinable S m 3 (fun _ v => DoubleTest (v 0) (v 1) (v 2)) := by
have hs : UniformDefinable S m 3 (fun _ v => isSet (v 0).val = true) := by
simpa using hset.reindex (![0] : Fin 1 → Fin 3)
have hbody : UniformDefinable S m 4 (fun _ v => (v 0).val ∈ (v 1).val ↔ v 0 = v 2 ∨ v 0 = v 3) := by
have hmem' : UniformDefinable S m 4 (fun _ v => (v 0).val ∈ (v 1).val) := by
simpa using hmem.reindex (![0,1] : Fin 2 → Fin 4)
exact hmem'.iff ((UniformDefinable.equal 0 2).or (UniformDefinable.equal 0 3))
exact hs.and (hbody.all (by omega))
variable (hd : ∀ i, ∀ x ∈ d i, ∀ y, y ∈ x → y ∈ d i)
include hd
theorem uniform_pair : UniformDefinable S m 3 (fun _ v => (v 0).val = pair (v 1).val (v 2).val) := by
have h1 : UniformDefinable S m 5 (fun _ v => SingletonTest (v 1) (v 3)) := by
simpa using (uniform_singleton S hmem hset hm).reindex (![1,3] : Fin 2 → Fin 5)
have h2 : UniformDefinable S m 5 (fun _ v => DoubleTest (v 0) (v 3) (v 4)) := by
simpa using (uniform_double S hmem hset hm).reindex (![0,3,4] : Fin 3 → Fin 5)
have h3 : UniformDefinable S m 5 (fun _ v => DoubleTest (v 2) (v 1) (v 0)) := by
simpa using (uniform_double S hmem hset hm).reindex (![2,1,0] : Fin 3 → Fin 5)
have hp := ((h1.and (h2.and h3)).ex (by omega)).ex (by omega)
apply hp.congr
intro i v
exact pairTest_iff (hd i) (v 0) (v 1) (v 2)
theorem uniform_ordinal (hpure : ∀ i k, ordinal (A := A i) k ∈ d i) (k : ℕ) :
UniformDefinable S m 1 (fun _ v => (v 0).val = ordinal k) := by
induction k using Nat.strong_induction_on with
| h k ih =>
have hor : UniformDefinable S m 2 (fun _ v => ∃ j ∈ range k, (v 0).val = ordinal j) := by
apply UniformDefinable.exists_finset
intro j hj
simpa using (ih j (mem_range.mp hj)).reindex (![0] : Fin 1 → Fin 2)
have hbody := (hmem.iff hor).all (by omega : 1 < m)
apply (hset.and hbody).congr
intro i v
change (isSet (v 0).val = true ∧ ∀ w : Domain (d i),
w.val ∈ (v 0).val ↔ ∃ j ∈ range k, w.val = ordinal j) ↔ _
constructor
· rintro ⟨hv,h⟩
apply ext_sets hv (ordinal_isSet k)
intro w
rw [mem_ordinal]
constructor
· intro hw
obtain ⟨j,hj,hjw⟩ := (h ⟨w,hd i _ (v 0).property _ hw⟩).mp hw
exact ⟨j,mem_range.mp hj,hjw⟩
· rintro ⟨j,hj,rfl⟩
exact (h ⟨ordinal j,hpure i j⟩).mpr ⟨j,mem_range.mpr hj,rfl⟩
· intro hv
refine ⟨by rw [hv]; exact ordinal_isSet k,?_⟩
intro w
rw [hv,mem_ordinal]
simp only [mem_range]
end
end WitnessedSeparation.HFCoding
namespace WitnessedSeparation.Interpretations
noncomputable section
open Classical Finset Hereditary
variable {R T : Type} {S S' : Structure R}
structure Structure.Iso (S S' : Structure R) where
equiv : S.Carrier ≃ S'.Carrier
rel : ∀ r x y, S.rel r x y = S'.rel r (equiv x) (equiv y)
namespace Structure.Iso
variable (e : S.Iso S')
def symm : S'.Iso S where
equiv := e.equiv.symm
rel r x y := by simpa using (e.rel r (e.equiv.symm x) (e.equiv.symm y)).symm
theorem eval {n : ℕ} (φ : Formula R n) (v : Fin n → S.Carrier) :
φ.eval S v ↔ φ.eval S' (e.equiv ∘ v) := by
induction φ with
| falsum => rfl
| eq x y => simp only [Formula.eval,Function.comp_apply,Equiv.apply_eq_iff_eq]
| rel r x y => simp only [Formula.eval,Function.comp_apply,e.rel]
| neg φ ih => exact not_congr (ih v)
| and φ ψ ihφ ihψ => exact and_congr (ihφ v) (ihψ v)
| ex φ ih =>
constructor
· rintro ⟨a,ha⟩
refine ⟨e.equiv a,?_⟩
simpa only [Fin.comp_cons] using (ih (Fin.cons a v)).mp ha
· rintro ⟨b,hb⟩
obtain ⟨a,rfl⟩ := e.equiv.surjective b
exact ⟨a,(ih (Fin.cons a v)).mpr (by simpa only [Fin.comp_cons] using hb)⟩
| hartig φ ψ ihφ ihψ =>
have hφ : ∀ a, φ.eval S (Fin.cons a v) ↔ φ.eval S' (Fin.cons (e.equiv a) (e.equiv ∘ v)) :=
fun a => by simpa only [Fin.comp_cons] using ihφ (Fin.cons a v)
have hψ : ∀ a, ψ.eval S (Fin.cons a v) ↔ ψ.eval S' (Fin.cons (e.equiv a) (e.equiv ∘ v)) :=
fun a => by simpa only [Fin.comp_cons] using ihψ (Fin.cons a v)
change Nat.card _ = Nat.card _ ↔ Nat.card _ = Nat.card _
rw [Nat.card_congr (e.equiv.subtypeEquiv (q := fun a : S'.Carrier => φ.eval S' (Fin.cons a (e.equiv ∘ v))) hφ),Nat.card_congr (e.equiv.subtypeEquiv (q := fun a : S'.Carrier => ψ.eval S' (Fin.cons a (e.equiv ∘ v))) hψ)]
end Structure.Iso
namespace Interpretation
variable (I : Interpretation R T) (e : S.Iso S')
def domainEquiv : I.Domain S ≃ I.Domain S' :=
(Equiv.prodCongr e.equiv e.equiv).subtypeEquiv (fun a => by
have h := e.eval I.domain ![a.1,a.2]
have hh : e.equiv ∘ ![a.1,a.2] = ![e.equiv a.1,e.equiv a.2] := by
ext i; fin_cases i <;> rfl
simpa only [hh,Equiv.prodCongr_apply,Prod.map_fst,Prod.map_snd] using h)
@[simp] theorem domainEquiv_val (a : I.Domain S) :
(I.domainEquiv e a).val = (e.equiv a.val.1,e.equiv a.val.2) := rfl
theorem link_equiv (a b : I.Domain S) : I.link S a b ↔ I.link S' (I.domainEquiv e a) (I.domainEquiv e b) := by
have h := e.eval I.identify ![a.val.1,a.val.2,b.val.1,b.val.2]
have hh : e.equiv ∘ ![a.val.1,a.val.2,b.val.1,b.val.2] =
![e.equiv a.val.1,e.equiv a.val.2,e.equiv b.val.1,e.equiv b.val.2] := by
ext i; fin_cases i <;> rfl
simpa only [link,domainEquiv_val,hh] using h
private theorem eqvGen_map {α β : Type} (r : α → α → Prop) (s : β → β → Prop)
(f : α → β) (hf : ∀ a b, r a b → s (f a) (f b)) {a b : α} :
Relation.EqvGen r a b → Relation.EqvGen s (f a) (f b) := by
intro h
induction h with
| rel x y h => exact .rel _ _ (hf x y h)
| refl x => exact .refl _
| symm x y h ih => exact .symm _ _ ih
| trans x y z h h' ih ih' => exact .trans _ _ _ ih ih'
theorem class_equiv (a b : I.Domain S) :
I.classSetoid S a b ↔ I.classSetoid S' (I.domainEquiv e a) (I.domainEquiv e b) := by
change Relation.EqvGen (I.link S) a b ↔ Relation.EqvGen (I.link S') _ _
constructor
· exact eqvGen_map _ _ (I.domainEquiv e) (fun a b => (I.link_equiv e a b).mp)
· intro h
have hm := eqvGen_map (I.link S') (I.link S) (I.domainEquiv e).symm
(fun a b hab => (I.link_equiv e ((I.domainEquiv e).symm a) ((I.domainEquiv e).symm b)).mpr
(by simpa using hab)) h
simpa using hm
def vertexEquiv : I.Vertex S ≃ I.Vertex S' := Quotient.congr (I.domainEquiv e) (I.class_equiv e)
@[simp] theorem vertexEquiv_mk (a : I.Domain S) :
I.vertexEquiv e (Quotient.mk _ a) = Quotient.mk _ (I.domainEquiv e a) := rfl
def applyIso : (I.apply S).Iso (I.apply S') where
equiv := I.vertexEquiv e
rel r C D := by
simp only [Interpretation.apply,decide_eq_decide]
constructor
· rintro ⟨a,b,ha,hb,hr⟩
refine ⟨I.domainEquiv e a,I.domainEquiv e b,?_,?_,?_⟩
· exact congrArg (I.vertexEquiv e) ha
· exact congrArg (I.vertexEquiv e) hb
· have hh := (e.eval (I.relation r) ![a.val.1,a.val.2,b.val.1,b.val.2]).mp hr
have hv : (fun x => e.equiv (![a.val.1,a.val.2,b.val.1,b.val.2] x)) =
![(I.domainEquiv e a).val.1,(I.domainEquiv e a).val.2,(I.domainEquiv e b).val.1,(I.domainEquiv e b).val.2] := by
ext i; fin_cases i <;> rfl
exact hv ▸ hh
· rintro ⟨a,b,ha,hb,hr⟩
obtain ⟨a,rfl⟩ := (I.domainEquiv e).surjective a
obtain ⟨b,rfl⟩ := (I.domainEquiv e).surjective b
refine ⟨a,b,?_,?_,?_⟩
· apply (I.vertexEquiv e).injective
exact ha
· apply (I.vertexEquiv e).injective
exact hb
· apply (e.eval (I.relation r) ![a.val.1,a.val.2,b.val.1,b.val.2]).mpr
have hv : (fun x => e.equiv (![a.val.1,a.val.2,b.val.1,b.val.2] x)) =
![(I.domainEquiv e a).val.1,(I.domainEquiv e a).val.2,(I.domainEquiv e b).val.1,(I.domainEquiv e b).val.2] := by
ext i; fin_cases i <;> rfl
change Formula.eval S' (I.relation r) (fun x => e.equiv (![a.val.1,a.val.2,b.val.1,b.val.2] x))
rw [hv]
exact hr
end Interpretation
end
noncomputable section
open Classical Finset Hereditary
variable {R T A B : Type} {S S' : Structure R} (I : Interpretation R T)
theorem map_payload (e : S.Iso S') (f : A → B) (c : S.Carrier → HF A)
(c' : S'.Carrier → HF B) (hc : ∀ a, map f (c a) = c' (e.equiv a)) (C : I.Vertex S) :
map f (payload I S c C) = payload I S' c' (I.vertexEquiv e C) := by
rw [payload,map_ofFinset,payload]
apply ofFinset_inj.mpr
ext z
simp only [image_image,mem_image,mem_filter,mem_univ,true_and,Function.comp_apply]
constructor
· rintro ⟨a,ha,hz⟩
refine ⟨I.domainEquiv e a,?_,?_⟩
· exact congrArg (I.vertexEquiv e) ha
· simpa only [map_pair,hc,Interpretation.domainEquiv_val] using hz
· rintro ⟨a,ha,hz⟩
obtain ⟨a,rfl⟩ := (I.domainEquiv e).surjective a
refine ⟨a,(I.vertexEquiv e).injective ha,?_⟩
simpa only [map_pair,hc,Interpretation.domainEquiv_val] using hz
theorem map_vertexCode (e : S.Iso S') (f : A → B) (c : S.Carrier → HF A)
(c' : S'.Carrier → HF B) (hc : ∀ a, map f (c a) = c' (e.equiv a)) (j : ℕ) (C : I.Vertex S) :
map f (vertexCode I S c j C) = vertexCode I S' c' j (I.vertexEquiv e C) := by
simp only [vertexCode,map_pair,map_ordinal,map_payload I e f c c' hc]
private theorem map_mem_wrappers (f : A → B) {a b x : HF A} (hx : x ∈ wrappers a b) :
map f x ∈ wrappers (map f a) (map f b) := by
simp only [wrappers,Finset.mem_insert,Finset.mem_singleton] at hx ⊢
rcases hx with rfl|rfl|rfl <;> simp
theorem map_mem_pairFamily (e : S.Iso S') (f : A → B) (c : S.Carrier → HF A)
(c' : S'.Carrier → HF B) (hc : ∀ a, map f (c a) = c' (e.equiv a))
{x : HF A} (hx : x ∈ pairFamily I S c) : map f x ∈ pairFamily I S' c' := by
obtain ⟨p,_,hp⟩ := mem_biUnion.mp hx
apply mem_biUnion.mpr
refine ⟨I.domainEquiv e p,mem_univ _,?_⟩
simpa only [hc,Interpretation.domainEquiv_val] using map_mem_wrappers f hp
theorem map_mem_classFamily (e : S.Iso S') (f : A → B) (c : S.Carrier → HF A)
(c' : S'.Carrier → HF B) (hc : ∀ a, map f (c a) = c' (e.equiv a))
(j : ℕ) {x : HF A} (hx : x ∈ classFamily I S c j) : map f x ∈ classFamily I S' c' j := by
obtain ⟨C,_,hC⟩ := mem_biUnion.mp hx
apply mem_biUnion.mpr
refine ⟨I.vertexEquiv e C,mem_univ _,?_⟩
rcases mem_insert.mp hC with rfl|hC
· rw [map_payload I e f c c' hc]
exact mem_insert_self _ _
· apply mem_insert_of_mem
simpa only [map_payload I e f c c' hc,map_ordinal] using map_mem_wrappers f hC
namespace Program
variable {R : Type} (P : Program R) (S : Structure R)
def stateIso {S' : Structure R} (e : S.Iso S') : (j : ℕ) → (P.state S j).Iso (P.state S' j)
| 0 => P.init.applyIso e
| j+1 => P.step.applyIso (stateIso e j)
def code : (j : ℕ) → (P.state S j).Carrier → HF S.Carrier
| 0 => vertexCode P.init S atom 1
| j+1 => vertexCode P.step (P.state S j) (code j) (j+2)
theorem code_injective (j : ℕ) : Function.Injective (P.code S j) := by
induction j with
| zero => exact vertexCode_injective _ _ _ atom_injective _
| succ j ih => exact vertexCode_injective _ _ _ ih _
theorem map_code {S' : Structure R} (e : S.Iso S') (j : ℕ) (a : (P.state S j).Carrier) :
map e.equiv (P.code S j a) = P.code S' j ((P.stateIso S e j).equiv a) := by
induction j with
| zero => exact map_vertexCode P.init e e.equiv atom atom (fun a => map_atom _ _) _ a
| succ j ih =>
exact map_vertexCode P.step (P.stateIso S e j) e.equiv
(P.code S j) (P.code S' j) ih _ a
def baseFamily (B : ℕ) : Finset (HF S.Carrier) :=
univ.image atom ∪ (range (B+1)).image ordinal
def family (B : ℕ) : ℕ → Finset (HF S.Carrier)
| 0 => baseFamily S B
| j+1 => match j with
| 0 => family B 0 ∪ pairFamily P.init S atom ∪ classFamily P.init S atom 1
| k+1 => family B (k+1) ∪ pairFamily P.step (P.state S k) (P.code S k) ∪
classFamily P.step (P.state S k) (P.code S k) (k+2)
theorem family_mono (B j : ℕ) : P.family S B j ⊆ P.family S B (j+1) := by
cases j <;> exact fun x hx => mem_union_left _ (mem_union_left _ hx)
theorem base_subset_family (B j : ℕ) : baseFamily S B ⊆ P.family S B j := by
induction j with
| zero => exact Subset.rfl
| succ j ih => exact ih.trans (P.family_mono S B j)
theorem atom_mem_family (B j : ℕ) (a : S.Carrier) : atom a ∈ P.family S B j :=
P.base_subset_family S B j (mem_union_left _ (mem_image.mpr ⟨a,mem_univ _,rfl⟩))
theorem ordinal_mem_family (B j i : ℕ) (hi : i ≤ B) : ordinal i ∈ P.family S B j :=
P.base_subset_family S B j (mem_union_right _ (mem_image.mpr ⟨i,mem_range.mpr (by omega),rfl⟩))
theorem code_mem_family (B j : ℕ) (a : (P.state S j).Carrier) : P.code S j a ∈ P.family S B (j+1) := by
have memC {U V : Type} (I : Interpretation U V) (T : Structure U)
(c : T.Carrier → HF S.Carrier) (i : ℕ) (C : I.Vertex T) :
vertexCode I T c i C ∈ classFamily I T c i := by
exact mem_biUnion.mpr ⟨C,mem_univ _,mem_insert_of_mem (by simp [vertexCode,wrappers])⟩
cases j with
| zero => exact mem_union_right _ (memC _ _ _ _ _)
| succ j => exact mem_union_right _ (memC _ _ _ _ _)
theorem baseFamily_transitive (B : ℕ) :
∀ x ∈ baseFamily S B, ∀ y, y ∈ x → y ∈ baseFamily S B := by
intro x hx y hy
rcases mem_union.mp hx with hx|hx
· obtain ⟨a,_,rfl⟩ := mem_image.mp hx
exact False.elim (not_mem_atom _ _ hy)
· obtain ⟨i,hi,rfl⟩ := mem_image.mp hx
obtain ⟨k,hk,rfl⟩ := (mem_ordinal y i).mp hy
exact mem_union_right _ (mem_image.mpr ⟨k,mem_range.mpr (by have := mem_range.mp hi; omega),rfl⟩)
theorem family_transitive (B j : ℕ) (hj : j ≤ B) :
∀ x ∈ P.family S B j, ∀ y, y ∈ x → y ∈ P.family S B j := by
induction j with
| zero => exact baseFamily_transitive S B
| succ j ih =>
have hp := ih (by omega)
cases j with
| zero =>
exact stage_family_transitive P.init S atom 1 (P.family S B 0) hp
(P.atom_mem_family S B 0) (P.ordinal_mem_family S B 0 1 hj)
| succ k =>
exact stage_family_transitive P.step (P.state S k) (P.code S k) (k+2)
(P.family S B (k+1)) hp (P.code_mem_family S B k) (P.ordinal_mem_family S B (k+1) (k+2) hj)
theorem map_mem_baseFamily {S' : Structure R} (e : S.Iso S') (B : ℕ) {x : HF S.Carrier}
(hx : x ∈ baseFamily S B) : map e.equiv x ∈ baseFamily S' B := by
rcases mem_union.mp hx with hx|hx
· obtain ⟨a,_,rfl⟩ := mem_image.mp hx
exact mem_union_left _ (mem_image.mpr ⟨e.equiv a,mem_univ _,by simp⟩)
· obtain ⟨i,hi,rfl⟩ := mem_image.mp hx
exact mem_union_right _ (mem_image.mpr ⟨i,hi,by simp⟩)
theorem map_mem_family {S' : Structure R} (e : S.Iso S') (B j : ℕ) {x : HF S.Carrier}
(hx : x ∈ P.family S B j) : map e.equiv x ∈ P.family S' B j := by
induction j generalizing x with
| zero => exact map_mem_baseFamily S e B hx
| succ j ih =>
cases j with
| zero =>
rcases mem_union.mp hx with hx|hx
· rcases mem_union.mp hx with hx|hx
· exact mem_union_left _ (mem_union_left _ (ih hx))
· exact mem_union_left _ (mem_union_right _
(map_mem_pairFamily P.init e e.equiv atom atom (fun _ => map_atom _ _) hx))
· exact mem_union_right _ (map_mem_classFamily P.init e e.equiv atom atom (fun _ => map_atom _ _) _ hx)
| succ k =>
rcases mem_union.mp hx with hx|hx
· rcases mem_union.mp hx with hx|hx
· exact mem_union_left _ (mem_union_left _ (ih hx))
· exact mem_union_left _ (mem_union_right _
(map_mem_pairFamily P.step (P.stateIso S e k) e.equiv (P.code S k) (P.code S' k)
(P.map_code S e k) hx))
· exact mem_union_right _ (map_mem_classFamily P.step (P.stateIso S e k) e.equiv
(P.code S k) (P.code S' k) (P.map_code S e k) _ hx)
theorem baseFamily_card_le (B : ℕ) : (baseFamily S B).card ≤ Nat.card S.Carrier+B+1 := by
calc
(baseFamily S B).card ≤ (univ.image (atom : S.Carrier → HF S.Carrier)).card +
((range (B+1)).image (ordinal (A := S.Carrier))).card := card_union_le _ _
_ ≤ univ.card + (range (B+1)).card := Nat.add_le_add (card_image_le) (card_image_le)
_ = Nat.card S.Carrier+B+1 := by simp [Nat.card_eq_fintype_card,Nat.add_assoc]
theorem family_card_le (B j : ℕ) (hN : Nat.card S.Carrier ≤ B)
(hsize : ∀ k < j, Nat.card (P.state S k).Carrier ≤ B) :
(P.family S B j).card ≤ j*(3*B^2+4*B)+2*B+1 := by
induction j with
| zero =>
have h := baseFamily_card_le S B
simp only [Nat.zero_mul,Nat.zero_add]
exact h.trans (by omega)
| succ j ih =>
have hprev := ih (fun k hk => hsize k (by omega))
have hc := hsize j (by omega)
have one_step {U V : Type} (I : Interpretation U V) (T : Structure U)
(c : T.Carrier → HF S.Carrier) (tag : ℕ) (F : Finset (HF S.Carrier))
(hp : Nat.card T.Carrier ≤ B) (hq : Nat.card (I.Vertex T) ≤ B) :
(F ∪ pairFamily I T c ∪ classFamily I T c tag).card ≤ F.card+(3*B^2+4*B) := by
have h1 := pairFamily_card_le I T c
have h2 := classFamily_card_le I T c tag
rw [← Nat.card_eq_fintype_card] at h1 h2
have h1' : (pairFamily I T c).card ≤ 3*B^2 :=
h1.trans (Nat.mul_le_mul_left _ (Nat.pow_le_pow_left hp 2))
have h2' : (classFamily I T c tag).card ≤ 4*B := h2.trans (Nat.mul_le_mul_left _ hq)
have h3 := card_union_le (F ∪ pairFamily I T c) (classFamily I T c tag)
have h4 := card_union_le F (pairFamily I T c)
omega
have hstep : (P.family S B (j+1)).card ≤ (P.family S B j).card+(3*B^2+4*B) := by
cases j with
| zero => exact one_step P.init S atom 1 _ hN hc
| succ k => exact one_step P.step (P.state S k) (P.code S k) (k+2) _ (hsize k (by omega)) hc
nlinarith
theorem trace_family (B j : ℕ) (hB : 2 ≤ B) (hj : j ≤ B)
(hN : Nat.card S.Carrier ≤ B) (hsize : ∀ k < j, Nat.card (P.state S k).Carrier ≤ B) :
(P.family S B j).card ≤ 9*B^3 ∧
(∀ x ∈ P.family S B j, ∀ y, y ∈ x → y ∈ P.family S B j) ∧
(∀ e : S.Iso S, ∀ x ∈ P.family S B j, map e.equiv x ∈ P.family S B j) := by
refine ⟨?_,P.family_transitive S B j hj,fun e x hx => P.map_mem_family S e B j hx⟩
have h := P.family_card_le S B j hN hsize
have hj' := Nat.mul_le_mul_right (3*B^2+4*B) hj
have hp := Nat.mul_le_mul_left (B^2) hB
have hq := Nat.mul_le_mul_left B hB
nlinarith
end Program
end
noncomputable section
open Classical Finset
def Formula.scopedWidth {R : Type} : {n : ℕ} → Formula R n → ℕ
| n, .falsum => n
| n, .eq _ _ => n
| n, .rel _ _ _ => n
| _, .neg φ => φ.scopedWidth
| _, .and φ ψ => max φ.scopedWidth ψ.scopedWidth
| _, .ex φ => φ.scopedWidth
| _, .hartig φ ψ => max φ.scopedWidth ψ.scopedWidth
theorem Formula.context_le_width {R : Type} {n : ℕ} (φ : Formula R n) : n ≤ φ.scopedWidth := by
induction φ with
| falsum => exact le_refl _
| eq => exact le_refl _
| rel => exact le_refl _
| neg φ ih => exact ih
| and φ ψ ihφ ihψ => exact ihφ.trans (Nat.le_max_left _ _)
| ex φ ih => exact (Nat.le_succ _).trans ih
| hartig φ ψ ihφ ihψ => exact (Nat.le_succ _).trans (ihφ.trans (Nat.le_max_left _ _))
private def guardedEquiv {X Y : Type} (e : X → Y) (he : Function.Injective e)
(U : Y → Prop) (hU : ∀ y, U y ↔ ∃ x, e x = y) (p : X → Prop) (q : Y → Prop)
(hq : ∀ x, q (e x) ↔ p x) : {x : X // p x} ≃ {y : Y // U y ∧ q y} :=
Equiv.ofBijective (fun x => ⟨e x.val,⟨(hU _).mpr ⟨x.val,rfl⟩,(hq _).mpr x.property⟩⟩) (by
constructor
· intro x y hxy
apply Subtype.ext
exact he (congrArg Subtype.val hxy)
· rintro ⟨y,hy,hqy⟩
obtain ⟨x,rfl⟩ := (hU y).mp hy
exact ⟨⟨x,(hq _).mp hqy⟩,rfl⟩)
private theorem count_comparison {X Y U V : Type} [Fintype X] [Fintype Y]
(e : X ≃ U) (f : Y ≃ V) (B : ℕ) (hX : Nat.card X ≤ B) :
(∃ k ≤ B, Nonempty (U ≃ Fin k) ∧ Nonempty (V ≃ Fin k)) ↔ Nat.card X = Nat.card Y := by
constructor
· rintro ⟨k,_,⟨g⟩,⟨h⟩⟩
exact Nat.card_congr ((e.trans g).trans (f.trans h).symm)
· intro h
have hX' : Fintype.card X = Nat.card X := (Nat.card_eq_fintype_card).symm
have hY' : Fintype.card Y = Nat.card X := by rw [← Nat.card_eq_fintype_card,← h]
exact ⟨Nat.card X,hX,⟨e.symm.trans (Fintype.equivFinOfCardEq hX')⟩,
⟨f.symm.trans (Fintype.equivFinOfCardEq hY')⟩⟩
open Counting (UniformDefinable)
variable {ι R L : Type} {D : ι → Type}
variable (T : ι → Structure R) (S : ∀ i, Counting.Structure L (D i))
variable (e : ∀ i, (T i).Carrier → D i) (he : ∀ i, Function.Injective (e i))
variable (U : ∀ i, D i → Prop) (hU : ∀ i x, U i x ↔ ∃ a, e i a = x)
variable (rel : R → ∀ i, D i → D i → Prop)
variable (hrel : ∀ r i a b, rel r i (e i a) (e i b) ↔ (T i).rel r a b = true)
variable {m B : ℕ}
variable (hdU : UniformDefinable S m 1 (fun i v => U i (v 0)))
variable (hdR : ∀ r, UniformDefinable S m 2 (fun i v => rel r i (v 0) (v 1)))
variable (hB : ∀ i, Nat.card (T i).Carrier ≤ B)
include he hU hrel hdU hdR hB
theorem uniform_translate {n : ℕ} (φ : Formula R n) (hw : φ.scopedWidth < m) :
∃ Q : ∀ i, (Fin n → D i) → Prop, UniformDefinable S m n Q ∧
∀ i v, Q i (e i ∘ v) ↔ φ.eval (T i) v := by
induction φ with
| falsum => exact ⟨fun _ _ => False,UniformDefinable.falsum,fun _ _ => Iff.rfl⟩
| eq x y =>
exact ⟨fun _ v => v x = v y,UniformDefinable.equal x y,fun i _ => (he i).eq_iff⟩
| rel r x y =>
refine ⟨fun i v => rel r i (v x) (v y),?_,fun i v => hrel r i (v x) (v y)⟩
simpa using (hdR r).reindex ![x,y]
| neg φ ih =>
obtain ⟨Q,hQ,hq⟩ := ih hw
exact ⟨fun i v => ¬ Q i v,hQ.neg,fun i v => not_congr (hq i v)⟩
| and φ ψ ihφ ihψ =>
obtain ⟨Q,hQ,hq⟩ := ihφ (lt_of_le_of_lt (Nat.le_max_left _ _) hw)
obtain ⟨P,hP,hp⟩ := ihψ (lt_of_le_of_lt (Nat.le_max_right _ _) hw)
exact ⟨fun i v => Q i v ∧ P i v,hQ.and hP,fun i v => and_congr (hq i v) (hp i v)⟩
| @ex n φ ih =>
obtain ⟨Q,hQ,hq⟩ := ih hw
have hu : UniformDefinable S m (n+1) (fun i v => U i (v 0)) := by
simpa using hdU.reindex (fun _ : Fin 1 => (0 : Fin (n+1)))
have hn : n < m := lt_of_le_of_lt ((Nat.le_succ _).trans φ.context_le_width) hw
refine ⟨fun i v => ∃ x, U i x ∧ Q i (Fin.cons x v),(hu.and hQ).ex hn,?_⟩
intro i v
constructor
· rintro ⟨x,hux,hqx⟩
obtain ⟨a,rfl⟩ := (hU i x).mp hux
exact ⟨a,(hq i (Fin.cons a v)).mp (by simpa only [Fin.comp_cons] using hqx)⟩
· rintro ⟨a,ha⟩
exact ⟨e i a,(hU i _).mpr ⟨a,rfl⟩,by simpa only [Fin.comp_cons] using (hq i (Fin.cons a v)).mpr ha⟩
| @hartig n φ ψ ihφ ihψ =>
obtain ⟨Q,hQ,hq⟩ := ihφ (lt_of_le_of_lt (Nat.le_max_left _ _) hw)
obtain ⟨P,hP,hp⟩ := ihψ (lt_of_le_of_lt (Nat.le_max_right _ _) hw)
have hu : UniformDefinable S m (n+1) (fun i v => U i (v 0)) := by
simpa using hdU.reindex (fun _ : Fin 1 => (0 : Fin (n+1)))
have hn : n < m := lt_of_le_of_lt ((Nat.le_succ _).trans
(φ.context_le_width.trans (Nat.le_max_left _ _))) hw
refine ⟨_,(hu.and hQ).bounded_hartig (hu.and hP) hn B,?_⟩
intro i v
have eqQ := guardedEquiv (e i) (he i) (U i) (hU i)
(fun a => φ.eval (T i) (Fin.cons a v)) (fun x => Q i (Fin.cons x (e i ∘ v)))
(fun a => by simpa only [Fin.comp_cons] using (hq i (Fin.cons a v)))
have eqP := guardedEquiv (e i) (he i) (U i) (hU i)
(fun a => ψ.eval (T i) (Fin.cons a v)) (fun x => P i (Fin.cons x (e i ∘ v)))
(fun a => by simpa only [Fin.comp_cons] using (hp i (Fin.cons a v)))
have hc : Nat.card {a : (T i).Carrier // φ.eval (T i) (Fin.cons a v)} ≤ B := by
apply le_trans _ (hB i)
rw [Nat.card_eq_fintype_card,Nat.card_eq_fintype_card]
exact Fintype.card_subtype_le _
exact count_comparison eqQ eqP B hc
end
end WitnessedSeparation.Interpretations
namespace WitnessedSeparation.Reachability
noncomputable section
open Classical
variable {X : Type*} (r : X → X → Prop)
def Link (a b : X) : Prop := a = b ∨ r a b ∨ r b a
def Reach : ℕ → X → X → Prop
| 0, a, b => Link r a b
| t+1, a, b => Reach t a b ∨ ∃ d, Reach t a d ∧ Link r d b
theorem mono {s t : ℕ} (h : s ≤ t) {a b : X} : Reach r s a b → Reach r t a b := by
induction h with
| refl => exact id
| @step t h ih => exact fun hr => Or.inl (ih hr)
theorem left_extend {t : ℕ} {a b c : X} (hab : Link r a b) (hbc : Reach r t b c) :
Reach r (t+1) a c := by
induction t generalizing c with
| zero => exact Or.inr ⟨b,hab,hbc⟩
| succ t ih =>
rcases hbc with hbc | ⟨d,hbd,hdc⟩
· exact Or.inl (ih hbc)
· exact Or.inr ⟨d,ih hbd,hdc⟩
theorem link_eqv {a b : X} (h : Link r a b) : Relation.EqvGen r a b := by
rcases h with rfl | h | h
· exact .refl a
· exact .rel a b h
· exact .symm b a (.rel b a h)
theorem reach_eqv {t : ℕ} {a b : X} (h : Reach r t a b) : Relation.EqvGen r a b := by
induction t generalizing b with
| zero => exact link_eqv r h
| succ t ih =>
rcases h with h | ⟨d,had,hdb⟩
· exact ih h
· exact .trans a d b (ih had) (link_eqv r hdb)
def graph : SimpleGraph X where
Adj a b := (r a b ∨ r b a) ∧ a ≠ b
symm := ⟨fun _ _ ⟨h,hn⟩ => ⟨h.symm,Ne.symm hn⟩⟩
loopless := ⟨fun _ h => h.2 rfl⟩
theorem eqv_walk {a b : X} (h : Relation.EqvGen r a b) : Nonempty ((graph r).Walk a b) := by
induction h with
| rel a b h =>
by_cases hab : a = b
· subst b; exact ⟨.nil⟩
· exact ⟨.cons ⟨Or.inl h,hab⟩ .nil⟩
| refl a => exact ⟨.nil⟩
| symm a b _ ih => exact ih.map (fun p => p.reverse)
| trans a b c _ _ ih ij =>
obtain ⟨p⟩ := ih
obtain ⟨q⟩ := ij
exact ⟨p.append q⟩
theorem walk_reach {a b : X} (p : (graph r).Walk a b) : Reach r p.length a b := by
induction p with
| nil => exact Or.inl rfl
| cons h p ih => exact left_extend r (Or.inr h.1) ih
theorem eqv_iff_bounded [Fintype X] (B : ℕ) (hB : Fintype.card X ≤ B) (a b : X) :
Relation.EqvGen r a b ↔ Reach r B a b := by
constructor
· intro h
obtain ⟨p⟩ := eqv_walk r h
exact mono r (le_trans (Nat.le_of_lt (p.bypass_isPath.length_lt)) hB) (walk_reach r p.bypass)
· exact reach_eqv r
end
end WitnessedSeparation.Reachability
namespace WitnessedSeparation.Counting
noncomputable section
open Classical UniformDefinable
variable {ι R : Type*} {D : ι → Type*} (S : ∀ i, Structure R (D i)) {m : ℕ}
def PairReach (L : ∀ i, (Fin 4 → D i) → Prop) : ℕ → ∀ i, (Fin 4 → D i) → Prop
| 0, i, v => L i v
| t+1, i, v => PairReach L t i v ∨ ∃ x y,
PairReach L t i ![v 0,v 1,x,y] ∧ L i ![x,y,v 2,v 3]
theorem uniform_pairReach (L : ∀ i, (Fin 4 → D i) → Prop)
(hL : UniformDefinable S m 4 L) (hm : 6 ≤ m) (t : ℕ) :
UniformDefinable S m 4 (PairReach L t) := by
induction t with
| zero => exact hL
| succ t ih =>
have ha := ih.reindex (![2,3,1,0] : Fin 4 → Fin 6)
have hb := hL.reindex (![1,0,4,5] : Fin 4 → Fin 6)
apply ih.or
apply (((ha.and hb).ex (by omega)).ex (by omega)).congr
intro i v
apply exists_congr
intro x
apply exists_congr
intro y
have h₁ : Fin.cons y (Fin.cons x v) ∘ ![2,3,1,0] = ![v 0,v 1,x,y] := by ext k; fin_cases k <;> rfl
have h₂ : Fin.cons y (Fin.cons x v) ∘ ![1,0,4,5] = ![x,y,v 2,v 3] := by ext k; fin_cases k <;> rfl
rw [h₁,h₂]
end
noncomputable section
open Classical
variable {ι D₀ : Type*} (X : Type*) [Fintype X] (r : X → X → Prop)
variable (a b : X → D₀) (hinj : Function.Injective (fun x => (a x,b x)))
variable (L : (Fin 4 → D₀) → Prop)
variable (hL : ∀ v, L v ↔ ∃ p q, v 0 = a p ∧ v 1 = b p ∧
v 2 = a q ∧ v 3 = b q ∧ Reachability.Link r p q)
include hinj hL
omit [Fintype X] in
theorem pairReach_lift (t : ℕ) (v : Fin 4 → D₀) :
PairReach (fun _ : Unit => L) t () v ↔ ∃ p q, v 0 = a p ∧ v 1 = b p ∧
v 2 = a q ∧ v 3 = b q ∧ Reachability.Reach r t p q := by
induction t generalizing v with
| zero => exact hL v
| succ t ih =>
change (_ ∨ ∃ x y, _ ∧ _) ↔ _
constructor
· rintro (hv|⟨x,y,hv,hw⟩)
· obtain ⟨p,q,hp₁,hp₂,hq₁,hq₂,hpq⟩ := (ih v).mp hv
exact ⟨p,q,hp₁,hp₂,hq₁,hq₂,Or.inl hpq⟩
· obtain ⟨p,c,hp₁,hp₂,hc₁,hc₂,hpc⟩ := (ih _).mp hv
obtain ⟨c',q,hc'₁,hc'₂,hq₁,hq₂,hcq⟩ := (hL _).mp hw
have hc : c = c' := hinj (Prod.ext (hc₁.symm.trans hc'₁) (hc₂.symm.trans hc'₂))
subst c'
exact ⟨p,q,hp₁,hp₂,hq₁,hq₂,Or.inr ⟨c,hpc,hcq⟩⟩
· rintro ⟨p,q,hp₁,hp₂,hq₁,hq₂,hpq⟩
rcases hpq with hpq | ⟨c,hpc,hcq⟩
· exact Or.inl ((ih v).mpr ⟨p,q,hp₁,hp₂,hq₁,hq₂,hpq⟩)
· exact Or.inr ⟨a c,b c,(ih _).mpr ⟨p,c,hp₁,hp₂,rfl,rfl,hpc⟩,
(hL _).mpr ⟨c,q,rfl,rfl,hq₁,hq₂,hcq⟩⟩
theorem pairReach_eqv (B : ℕ) (hB : Fintype.card X ≤ B) (v : Fin 4 → D₀) :
PairReach (fun _ : Unit => L) B () v ↔ ∃ p q, v 0 = a p ∧ v 1 = b p ∧
v 2 = a q ∧ v 3 = b q ∧ Relation.EqvGen r p q := by
rw [pairReach_lift X r a b hinj L hL]
simp only [← Reachability.eqv_iff_bounded r B hB]
end
end WitnessedSeparation.Counting
end OAI
import OAI.Computability.WitnessedChoice.FormTransfer
namespace OAI
namespace WitnessedSeparation.HFCoding
noncomputable section
open Classical Finset Hereditary Counting
variable {A R : Type} {d : Set (HF A)}
abbrev Domain (d : Set (HF A)) := {x : HF A // x ∈ d}
variable (hd : ∀ x ∈ d, ∀ y, y ∈ x → y ∈ d)
variable (S : Counting.Structure R (Domain d)) {m : ℕ}
def SingletonTest (u a : Domain d) : Prop :=
isSet u.val = true ∧ ∀ w : Domain d, w.val ∈ u.val ↔ w = a
def DoubleTest (u a b : Domain d) : Prop :=
isSet u.val = true ∧ ∀ w : Domain d, w.val ∈ u.val ↔ w = a ∨ w = b
include hd
theorem singletonTest_iff (u a : Domain d) : SingletonTest u a ↔ u.val = Hereditary.singleton a.val := by
constructor
· rintro ⟨hu,h⟩
apply ext_sets hu (isSet_ofFinset _)
intro w
change w ∈ u.val ↔ w ∈ Hereditary.singleton a.val
rw [Hereditary.mem_singleton]
constructor
· intro hw
exact congrArg Subtype.val ((h ⟨w,hd _ u.property _ hw⟩).mp hw)
· rintro rfl
exact (h a).mpr rfl
· intro h
constructor
· rw [h]; exact isSet_ofFinset _
· intro w
rw [h,Hereditary.mem_singleton]
exact Subtype.val_injective.eq_iff
theorem doubleTest_iff (u a b : Domain d) : DoubleTest u a b ↔ u.val = double a.val b.val := by
constructor
· rintro ⟨hu,h⟩
apply ext_sets hu (isSet_ofFinset _)
intro w
change w ∈ u.val ↔ w ∈ double a.val b.val
rw [mem_double]
constructor
· intro hw
rcases (h ⟨w,hd _ u.property _ hw⟩).mp hw with h|h
· exact Or.inl (congrArg Subtype.val h)
· exact Or.inr (congrArg Subtype.val h)
· rintro (rfl|rfl)
· exact (h a).mpr (Or.inl rfl)
· exact (h b).mpr (Or.inr rfl)
· intro h
constructor
· rw [h]; exact isSet_ofFinset _
· intro w
rw [h,mem_double]
exact or_congr Subtype.val_injective.eq_iff Subtype.val_injective.eq_iff
def PairTest (z a b : Domain d) : Prop :=
∃ u v : Domain d, SingletonTest u a ∧ DoubleTest v a b ∧ DoubleTest z u v
theorem pairTest_iff (z a b : Domain d) : PairTest z a b ↔ z.val = pair a.val b.val := by
constructor
· rintro ⟨u,v,hu,hv,hz⟩
rw [singletonTest_iff hd] at hu
rw [doubleTest_iff hd] at hv hz
simpa only [hu,hv,pair] using hz
· intro hz
have hu : Hereditary.singleton a.val ∈ d := hd _ z.property _ (by rw [hz]; simp [pair])
have hv : double a.val b.val ∈ d := hd _ z.property _ (by rw [hz]; simp [pair])
refine ⟨⟨Hereditary.singleton a.val,hu⟩,⟨double a.val b.val,hv⟩,?_,?_,?_⟩
· exact (singletonTest_iff hd _ _).mpr rfl
· exact (doubleTest_iff hd _ _ _).mpr rfl
· exact (doubleTest_iff hd _ _ _).mpr hz
variable (hmem : Definable S m 2 (fun v => (v 0).val ∈ (v 1).val))
variable (hset : Definable S m 1 (fun v => isSet (v 0).val = true))
variable (hm : 6 ≤ m)
include hmem hset hm
omit hd in
theorem singleton_definable : Definable S m 2 (fun v => SingletonTest (v 0) (v 1)) := by
have hs : Definable S m 2 (fun v => isSet (v 0).val = true) := by
simpa using hset.reindex (![0] : Fin 1 → Fin 2)
have hbody : Definable S m 3 (fun v => (v 0).val ∈ (v 1).val ↔ v 0 = v 2) := by
have hmem' : Definable S m 3 (fun v => (v 0).val ∈ (v 1).val) := by
simpa using hmem.reindex (![0,1] : Fin 2 → Fin 3)