File size: 4,430 Bytes
3277efa | 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 | import OAI.SetTheory.PartitionPrinciple.Definability.GroundRefinementPairClassGraphs
namespace OAI
namespace PartitionPilot.Forcing
open SetRealization
universe u
def natIterate {B : Type u} (f : B → B) (b : B) : Nat → B
| 0 => b
| n + 1 => f (natIterate f b n)
structure IterationTraceCode (N D B step base t : ZFSet.{u}) : Prop where
function : ZFSet.IsFunc D B t
seed : ZFSet.pair ∅ base ∈ t
next : ∀ i ∈ N, ∀ j ∈ D, ∀ x ∈ B, ∀ y ∈ B,
j = insert i i → ZFSet.pair i x ∈ t → ZFSet.pair j y ∈ t → ZFSet.pair x y ∈ step
noncomputable def finiteIterationTrace {B : Type u} (s : Presentation B) (f : B → B)
(b : B) (n : Nat) : ZFSet.{u} :=
(natInitialPresentation (n + 1)).graph s (fun i => natIterate f b i.down.val)
theorem pair_mem_finiteIterationTrace {B : Type u} (s : Presentation B) (f : B → B)
(b : B) (n k : Nat) (y : ZFSet.{u}) :
ZFSet.pair (natSetCode k) y ∈ finiteIterationTrace s f b n ↔
k ≤ n ∧ y = s.encode (natIterate f b k) := by
rw [finiteIterationTrace, Presentation.mem_graph]
constructor
· rintro ⟨i, eq⟩
obtain ⟨first, second⟩ := ZFSet.pair_inj.1 eq
have same : i.down.val = k := natSetCode_injective first
exact ⟨by have := i.down.isLt; omega, by simpa only [same] using second.symm⟩
· rintro ⟨hk, rfl⟩
exact ⟨⟨⟨k, by omega⟩⟩, rfl⟩
theorem finiteIterationTrace_code {B : Type u} (s : Presentation B) (f : B → B)
(b : B) (n : Nat) :
IterationTraceCode (natSetCode n) (natSetCode (n + 1)) s.carrier
(s.graph s f) (s.encode b) (finiteIterationTrace s f b n) := by
refine ⟨(natInitialPresentation (n + 1)).graph_isFunc s _, ?_, ?_⟩
· exact (pair_mem_finiteIterationTrace s f b n 0 _).2 ⟨Nat.zero_le _, rfl⟩
· intro i hi j _ x _ y _ successor prev next
obtain ⟨k, hk, rfl⟩ := (mem_natSetCode i n).1 hi
have previous := ((pair_mem_finiteIterationTrace s f b n k x).1 prev).2
have jcode : j = natSetCode (k + 1) := successor
have following := ((pair_mem_finiteIterationTrace s f b n (k + 1) y).1 (jcode ▸ next)).2
rw [previous, following]
exact (s.pair_mem_graph s f _ _).2 rfl
theorem IterationTraceCode.value {B : Type u} (s : Presentation B) (f : B → B) (b : B)
{n : Nat} {t : ZFSet.{u}}
(trace : IterationTraceCode (natSetCode n) (natSetCode (n + 1)) s.carrier
(s.graph s f) (s.encode b) t) :
∀ k ≤ n, ZFSet.pair (natSetCode k) (s.encode (natIterate f b k)) ∈ t := by
intro k
induction k with
| zero => exact fun _ => trace.seed
| succ k ih =>
intro hk
have domain := (natSetCode_mem_iff (k + 1) (n + 1)).2 (by omega)
obtain ⟨y, rel, _⟩ := trace.function.2 (natSetCode (k + 1)) domain
have hy := (ZFSet.pair_mem_prod.1 (trace.function.1 rel)).2
obtain ⟨c, eq⟩ := (s.mem_carrier y).1 hy
have step := trace.next (natSetCode k) ((natSetCode_mem_iff k n).2 (by omega))
(natSetCode (k + 1)) domain _ (s.encode_mem _) y hy rfl (ih (by omega)) rel
rw [← eq] at step
have output := (s.pair_mem_graph s f _ c).1 step
have same : y = s.encode (natIterate f b (k + 1)) := eq.symm.trans (congrArg s.encode output.symm)
exact same ▸ rel
theorem IterationTraceCode.output {B : Type u} (s : Presentation B) (f : B → B) (b : B)
{n : Nat} {t y : ZFSet.{u}}
(trace : IterationTraceCode (natSetCode n) (natSetCode (n + 1)) s.carrier
(s.graph s f) (s.encode b) t) (rel : ZFSet.pair (natSetCode n) y ∈ t) :
y = s.encode (natIterate f b n) := by
obtain ⟨z, _, unique⟩ := trace.function.2 (natSetCode n)
((natSetCode_mem_iff n (n + 1)).2 (by omega))
exact (unique y rel).trans (unique _ (trace.value s f b n (Nat.le_refl n))).symm
namespace TransitiveGround
open SetFormula
theorem finiteIterationTrace_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)
{B : Type u} (s : Presentation B) (f : B → B) (b : B) (n : Nat)
(hB : s.carrier ∈ M.sets) : finiteIterationTrace s f b n ∈ M.sets :=
M.finite_function_graph_mem pairing unions (natInitialPresentation (n + 1)) s _
(M.natSetCode_mem separation infinite (n + 1)) hB
end TransitiveGround
end PartitionPilot.Forcing
end OAI
|