File size: 8,778 Bytes
e3e0a0d | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 | import OAI.SetTheory.PartitionPrinciple.Geometry.FiniteIterationTraces
namespace OAI
namespace PartitionPilot.Forcing
section
open SetRealization
universe u
variable {B : Type u} (s : Presentation B)
noncomputable def finiteWordGraph (xs : List B) : ZFSet.{u} :=
(natInitialPresentation xs.length).graph s (fun i => xs.get i.down)
theorem finiteWordGraph_function (xs : List B) :
ZFSet.IsFunc (natSetCode xs.length) s.carrier (finiteWordGraph s xs) :=
(natInitialPresentation xs.length).graph_isFunc s _
theorem mem_finiteWordGraph (xs : List B) (z : ZFSet.{u}) :
z ∈ finiteWordGraph s xs ↔
∃ i : Fin xs.length, z = ZFSet.pair (natSetCode i.val) (s.encode (xs.get i)) := by
rw [finiteWordGraph, Presentation.mem_graph]
exact ⟨fun ⟨i, eq⟩ => ⟨i.down, eq.symm⟩, fun ⟨i, eq⟩ => ⟨⟨i⟩, eq.symm⟩⟩
theorem pair_mem_finiteWordGraph (xs : List B) (k : Nat) (y : ZFSet.{u}) :
ZFSet.pair (natSetCode k) y ∈ finiteWordGraph s xs ↔
∃ h : k < xs.length, y = s.encode (xs.get ⟨k, h⟩) := by
rw [mem_finiteWordGraph]
constructor
· rintro ⟨i, eq⟩
obtain ⟨first, second⟩ := ZFSet.pair_inj.1 eq
have same : k = i.val := natSetCode_injective first
subst k
exact ⟨i.isLt, second⟩
· rintro ⟨h, eq⟩
exact ⟨⟨k, h⟩, congrArg (ZFSet.pair (natSetCode k)) eq⟩
theorem finiteWordGraph_nil : finiteWordGraph s [] = ∅ := by
apply ZFSet.ext
intro z
rw [mem_finiteWordGraph]
exact ⟨fun ⟨i, _⟩ => False.elim (Nat.not_lt_zero i.val i.isLt),
fun h => False.elim (ZFSet.notMem_empty z h)⟩
theorem exists_finiteWordGraph {n : Nat} {f : ZFSet.{u}}
(function : ZFSet.IsFunc (natSetCode n) s.carrier f) :
∃ xs : List B, xs.length = n ∧ finiteWordGraph s xs = f := by
classical
have values (i : Fin n) : ∃ b : B, ZFSet.pair (natSetCode i.val) (s.encode b) ∈ f := by
obtain ⟨y, entry, _⟩ := function.2 (natSetCode i.val) ((natSetCode_mem_iff i.val n).2 i.isLt)
obtain ⟨b, eq⟩ := (s.mem_carrier y).1 (ZFSet.pair_mem_prod.1 (function.1 entry)).2
exact ⟨b, eq.symm ▸ entry⟩
let value : Fin n → B := fun i => Classical.choose (values i)
have entry (i : Fin n) : ZFSet.pair (natSetCode i.val) (s.encode (value i)) ∈ f :=
Classical.choose_spec (values i)
let xs := List.ofFn value
have length : xs.length = n := List.length_ofFn
refine ⟨xs, length, ?_⟩
have graphFunction : FunctionGraphOn (natSetCode n) (finiteWordGraph s xs) := by
rw [← length]
exact ⟨s.carrier, finiteWordGraph_function s xs⟩
apply graphFunction.eq_of_agree ⟨s.carrier, function⟩
intro x y z xy xz
obtain ⟨i, eq⟩ := (mem_finiteWordGraph s xs _).1 xy
obtain ⟨first, second⟩ := ZFSet.pair_inj.1 eq
have hi : i.val < n := length ▸ i.isLt
have getValue : xs.get i = value ⟨i.val, hi⟩ := by
simp only [xs, List.get_eq_getElem, List.getElem_ofFn]
have original : ZFSet.pair x y ∈ f := by
rw [first, second, getValue]
exact entry ⟨i.val, hi⟩
exact (show FunctionGraphOn (natSetCode n) f from ⟨s.carrier, function⟩).unique original xz
namespace TransitiveGround
open SetFormula
theorem finiteWordGraph_mem (M : TransitiveGround.{u})
(pairing : Realize M.sets SetFormula.pairing Fin.elim0)
(unions : Realize M.sets SetFormula.union Fin.elim0)
(separation : SeparationSchema M.sets)
(infinite : Realize M.sets SetFormula.infinity Fin.elim0)
(xs : List B) (hB : s.carrier ∈ M.sets) : finiteWordGraph s xs ∈ M.sets :=
M.finite_function_graph_mem pairing unions (natInitialPresentation xs.length) s _
(M.natSetCode_mem separation infinite xs.length) hB
end TransitiveGround
theorem finiteWordGraph_injective : Function.Injective (finiteWordGraph s) := by
intro xs ys eq
have other : ZFSet.IsFunc (natSetCode ys.length) s.carrier (finiteWordGraph s xs) :=
eq.symm ▸ finiteWordGraph_function s ys
have length := finiteWord_domain_unique (finiteWordGraph_function s xs) other
apply List.ext_get length
intro k hx hy
apply s.injective
have first := (pair_mem_finiteWordGraph s xs k _).2 ⟨hx, rfl⟩
have second := (pair_mem_finiteWordGraph s ys k _).2 ⟨hy, rfl⟩
rw [eq] at first
exact (show FunctionGraphOn (natSetCode ys.length) (finiteWordGraph s ys) from
⟨s.carrier, finiteWordGraph_function s ys⟩).unique first second
namespace TransitiveGround
open SetFormula
variable (M : TransitiveGround.{u})
variable (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
variable (unions : Realize M.sets SetFormula.union Fin.elim0)
variable (separation : SeparationSchema M.sets)
variable (infinite : Realize M.sets SetFormula.infinity Fin.elim0)
variable (hB : s.carrier ∈ M.sets)
include pairing unions separation infinite hB
theorem finiteWordGraph_mem_finiteWords (xs : List B) :
finiteWordGraph s xs ∈ M.finiteWords s.carrier :=
(M.mem_finiteWords s.carrier _).2
⟨finiteWordGraph_mem s M pairing unions separation infinite xs hB,
xs.length, finiteWordGraph_function s xs⟩
theorem finiteWords_exact_lists (f : ZFSet.{u}) :
f ∈ M.finiteWords s.carrier ↔ ∃ xs : List B, finiteWordGraph s xs = f := by
constructor
· intro hf
obtain ⟨_, n, function⟩ := (M.mem_finiteWords s.carrier f).1 hf
obtain ⟨xs, _, eq⟩ := exists_finiteWordGraph s function
exact ⟨xs, eq⟩
· rintro ⟨xs, rfl⟩
exact finiteWordGraph_mem_finiteWords s M pairing unions separation infinite hB xs
noncomputable def finiteWordPresentation : Presentation (List B) where
carrier := M.finiteWords s.carrier
encode := finiteWordGraph s
injective := finiteWordGraph_injective s
mem_carrier := finiteWords_exact_lists s M pairing unions separation infinite hB
end TransitiveGround
end
open SetRealization SetFormula
universe u
def FiniteWordMapCode (omega A B e f g : ZFSet.{u}) : Prop :=
∃ n ∈ omega, ZFSet.IsFunc n A f ∧ ZFSet.IsFunc n B g ∧
∀ i ∈ n, ∀ x ∈ A, ∀ y ∈ B,
ZFSet.pair i x ∈ f → ZFSet.pair i y ∈ g → ZFSet.pair x y ∈ e
namespace BoundedFormula
def finiteWordMapFormula {k} (omega a b e f g : Fin k) : BoundedFormula k :=
exMem omega (.conj (functionFormula 0 a.succ f.succ)
(.conj (functionFormula 0 b.succ g.succ)
(.allMem 0 (.allMem a.succ.succ (.allMem b.succ.succ.succ
(imp (pairMembershipFormula 2 1 f.succ.succ.succ.succ)
(imp (pairMembershipFormula 2 0 g.succ.succ.succ.succ)
(pairMembershipFormula 1 0 e.succ.succ.succ.succ))))))))
theorem truth_finiteWordMapFormula {k} (omega a b e f g : Fin k)
(env : Fin k → ZFSet.{u}) :
Truth (finiteWordMapFormula omega a b e f g) env ↔
FiniteWordMapCode (env omega) (env a) (env b) (env e) (env f) (env g) := by
simp only [finiteWordMapFormula, truth_exMem, Truth, truth_functionFormula,
truth_imp, truth_pairMembershipFormula, FiniteWordMapCode]
rfl
end BoundedFormula
theorem finiteWordMapCode_iff {B D : Type u} (s : Presentation B) (t : Presentation D)
(e : B → D) (xs : List B) (ys : List D) :
FiniteWordMapCode ZFSet.omega s.carrier t.carrier (s.graph t e)
(finiteWordGraph s xs) (finiteWordGraph t ys) ↔ ys = xs.map e := by
constructor
· rintro ⟨n, hn, first, second, maps⟩
obtain ⟨n, rfl⟩ := (mem_omega_iff_natSetCode n).1 hn
have firstLength := finiteWord_domain_unique first (finiteWordGraph_function s xs)
have secondLength := finiteWord_domain_unique second (finiteWordGraph_function t ys)
have length : ys.length = (xs.map e).length := by simp only [List.length_map]; omega
apply List.ext_get length
intro i hi hj
have hxs : i < xs.length := by simpa only [List.length_map] using hj
have entry := maps (natSetCode i) ((natSetCode_mem_iff i n).2 (by omega))
(s.encode (xs.get ⟨i, hxs⟩)) (s.encode_mem _)
(t.encode (ys.get ⟨i, hi⟩)) (t.encode_mem _)
((pair_mem_finiteWordGraph s xs i _).2 ⟨hxs, rfl⟩)
((pair_mem_finiteWordGraph t ys i _).2 ⟨hi, rfl⟩)
have same := (s.pair_mem_graph t e _ _).1 entry
simpa only [List.get_eq_getElem, List.getElem_map] using same.symm
· rintro rfl
refine ⟨natSetCode xs.length, natSetCode_mem_omega _, finiteWordGraph_function s xs, ?_, ?_⟩
· simpa only [List.length_map] using finiteWordGraph_function t (xs.map e)
· intro i hi x _ y _ source target
obtain ⟨k, hk, rfl⟩ := (mem_natSetCode i xs.length).1 hi
obtain ⟨_, rfl⟩ := (pair_mem_finiteWordGraph s xs k x).1 source
obtain ⟨_, rfl⟩ := (pair_mem_finiteWordGraph t (xs.map e) k y).1 target
apply (s.pair_mem_graph t e _ _).2
simp only [List.get_eq_getElem, List.getElem_map]
end PartitionPilot.Forcing
end OAI
|