File size: 8,518 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 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 | import OAI.SetTheory.PartitionPrinciple.Geometry.GroundFairPreparationMonotonicity
namespace OAI
section
namespace PartitionPilot.Forcing.TransitiveGround
open SetFormula
universe u
variable (M : TransitiveGround.{u})
noncomputable def fairPreparationConditionGraph
(Q stages U E0 orbit : ZFSet.{u}) : ZFSet.{u} :=
let tail := ZFSet.prod (M.groundRelations ZFSet.omega E0) (insert ∅ (ZFSet.prod stages U))
let middle := ZFSet.prod Q tail
let bound := ZFSet.prod ZFSet.omega middle
relationCompose ZFSet.omega middle Q
(relationCompose ZFSet.omega bound middle orbit (productSecond ZFSet.omega middle))
(productFirst Q tail)
theorem fairPreparationConditionGraph_function
{Q stages U E0 enumSelector orbit : ZFSet.{u}}
(function : ZFSet.IsFunc ZFSet.omega
(M.fairPreparationStates Q stages U E0 enumSelector) orbit) :
ZFSet.IsFunc ZFSet.omega Q (M.fairPreparationConditionGraph Q stages U E0 orbit) := by
let tail := ZFSet.prod (M.groundRelations ZFSet.omega E0) (insert ∅ (ZFSet.prod stages U))
let middle := ZFSet.prod Q tail
have widened : ZFSet.IsFunc ZFSet.omega (ZFSet.prod ZFSet.omega middle) orbit := by
refine ⟨?_, function.2⟩
intro z member
obtain ⟨i, hi, state, hs, rfl⟩ := ZFSet.mem_prod.1 (function.1 member)
exact ZFSet.pair_mem_prod.2 ⟨hi, ((M.mem_fairPreparationStates _ _ _ _ _ _).1 hs).1⟩
exact relationCompose_function_of_subset
(relationCompose_function_of_subset widened
(productSecond_function ZFSet.omega middle) (fun _ h => h))
(productFirst_function Q tail) (fun _ h => h)
theorem pair_mem_fairPreparationConditionGraph
{Q stages U E0 enumSelector orbit : ZFSet.{u}}
(function : ZFSet.IsFunc ZFSet.omega
(M.fairPreparationStates Q stages U E0 enumSelector) orbit)
(i p : ZFSet.{u}) :
ZFSet.pair i p ∈ M.fairPreparationConditionGraph Q stages U E0 orbit ↔
∃ clock births event,
ZFSet.pair i (ZFSet.pair clock (ZFSet.pair p (ZFSet.pair births event))) ∈ orbit := by
dsimp only [fairPreparationConditionGraph]
rw [pair_mem_relationCompose]
constructor
· rintro ⟨_, _, middle, _, first, second⟩
obtain ⟨_, _, state, _, edge, projected⟩ := (pair_mem_relationCompose _ _ _ _ _ _ _).1 first
obtain ⟨p', hp', tail, ht, eq⟩ := (mem_productFirst _ _ _).1 second
obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 eq
obtain ⟨clock, hc, rest, hr, eq⟩ := (mem_productSecond _ _ _).1 projected
obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 eq
obtain ⟨births, hb, event, he, rfl⟩ := ZFSet.mem_prod.1 ht
exact ⟨clock, births, event, edge⟩
· rintro ⟨clock, births, event, edge⟩
have bounds := ZFSet.pair_mem_prod.1 (function.1 edge)
have stateBound := ((M.mem_fairPreparationStates _ _ _ _ _ _).1 bounds.2).1
have split := ZFSet.pair_mem_prod.1 stateBound
have rest := ZFSet.pair_mem_prod.1 split.2
refine ⟨bounds.1, rest.1, _, split.2, ?_, ?_⟩
· exact (pair_mem_relationCompose _ _ _ _ _ _ _).2
⟨bounds.1, split.2, _, stateBound, edge,
(mem_productSecond _ _ _).2 ⟨clock, split.1, _, split.2, rfl⟩⟩
· exact (mem_productFirst _ _ _).2 ⟨p, rest.1, _, rest.2, rfl⟩
theorem fairPreparationConditionGraph_mem
(pairing : Realize M.sets SetFormula.pairing Fin.elim0)
(unions : Realize M.sets SetFormula.union Fin.elim0)
(powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
{Q stages U E0 orbit : ZFSet.{u}}
(hQ : Q ∈ M.sets) (hStages : stages ∈ M.sets) (hU : U ∈ M.sets)
(hE0 : E0 ∈ M.sets) (omega : ZFSet.omega ∈ M.sets) (whole : orbit ∈ M.sets) :
M.fairPreparationConditionGraph Q stages U E0 orbit ∈ M.sets := by
have hTail := M.prod_mem pairing unions powers separation
(M.groundRelations_mem pairing unions powers separation omega hE0)
(M.insert_mem pairing unions (M.empty_mem ⟨Q, hQ⟩)
(M.prod_mem pairing unions powers separation hStages hU))
have hMiddle := M.prod_mem pairing unions powers separation hQ hTail
exact M.relationCompose_mem pairing unions powers separation omega hMiddle hQ
(M.relationCompose_mem pairing unions powers separation omega
(M.prod_mem pairing unions powers separation omega hMiddle) hMiddle whole
(M.productSecond_mem pairing unions powers separation omega hMiddle))
(M.productFirst_mem pairing unions powers separation hQ hTail)
end PartitionPilot.Forcing.TransitiveGround
namespace PartitionPilot.Forcing.TransitiveGround
open SetFormula SetRealization
universe u
variable (M : TransitiveGround.{u}) {P : Type u} [Preorder P] (s : Presentation P)
theorem fairPreparationOrbit_conditionSequence
(pairing : Realize M.sets SetFormula.pairing Fin.elim0)
(unions : Realize M.sets SetFormula.union Fin.elim0)
(powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
{stages U E0 enumSelector prepSelector grid packed nodes T orbit : ZFSet.{u}}
(hQ : s.carrier ∈ M.sets) (hStages : stages ∈ M.sets) (hU : U ∈ M.sets)
(hE0 : E0 ∈ M.sets) (omega : ZFSet.omega ∈ M.sets) (whole : orbit ∈ M.sets)
(function : ZFSet.IsFunc ZFSet.omega
(M.fairPreparationStates s.carrier stages U E0 enumSelector) orbit)
(selected : prepSelector ⊆
M.varyingPreparationRelation stages packed s.carrier s.conditionOrder nodes T)
(p : P) (e : ZFSet.{u})
(initial : ∀ state, ZFSet.pair ∅ state ∈ orbit ↔
state = ZFSet.pair ∅ (ZFSet.pair (s.encode p) (ZFSet.pair {ZFSet.pair ∅ e} ∅)))
(steps : ∀ n ∈ ZFSet.omega, ∀ state next,
ZFSet.pair n state ∈ orbit → ZFSet.pair (insert n n) next ∈ orbit →
FairPreparationStepCode ZFSet.omega E0 stages U enumSelector prepSelector grid state next) :
∃ seq : Nat → P, seq 0 = p ∧
natPresentation.graph s (fun n => seq n.down) ∈ M.sets ∧ Antitone seq ∧
∃ clocks births events : Nat → ZFSet.{u},
clocks 0 = ∅ ∧ births 0 = {ZFSet.pair ∅ e} ∧ events 0 = ∅ ∧
(∀ k, ZFSet.pair (natSetCode k)
(ZFSet.pair (clocks k) (ZFSet.pair (s.encode (seq k))
(ZFSet.pair (births k) (events k)))) ∈ orbit) ∧
∀ k, FairPreparationStepCode ZFSet.omega E0 stages U enumSelector prepSelector grid
(ZFSet.pair (clocks k) (ZFSet.pair (s.encode (seq k)) (ZFSet.pair (births k) (events k))))
(ZFSet.pair (clocks (k + 1))
(ZFSet.pair (s.encode (seq (k + 1))) (ZFSet.pair (births (k + 1)) (events (k + 1))))) := by
let graph := M.fairPreparationConditionGraph s.carrier stages U E0 orbit
have graphGround : graph ∈ M.sets :=
M.fairPreparationConditionGraph_mem pairing unions powers separation hQ hStages hU hE0 omega whole
have graphFunction : ZFSet.IsFunc ZFSet.omega s.carrier graph :=
M.fairPreparationConditionGraph_function function
let seq : Nat → P := fun n => natPresentation.decodeFunction s graph graphFunction ⟨n⟩
have represented (k : Nat) : ∃ clock births event,
ZFSet.pair (natSetCode k)
(ZFSet.pair clock (ZFSet.pair (s.encode (seq k)) (ZFSet.pair births event))) ∈ orbit :=
(M.pair_mem_fairPreparationConditionGraph function _ _).1
(natPresentation.decodeFunction_mem s graph graphFunction ⟨k⟩)
choose clocks births events entries using represented
have atZero := (initial _).1 (entries 0)
have zeroClock := (ZFSet.pair_inj.1 atZero).1
have zeroCondition := (ZFSet.pair_inj.1 (ZFSet.pair_inj.1 atZero).2).1
have zeroTail := ZFSet.pair_inj.1 (ZFSet.pair_inj.1 (ZFSet.pair_inj.1 atZero).2).2
have rawSteps (k : Nat) := steps (natSetCode k) (natSetCode_mem_omega k)
_ _ (entries k) (entries (k + 1))
have decreasing : Antitone seq := by
apply antitone_nat_of_succ_le
intro k
apply (s.pair_mem_conditionOrder _ _).1
exact M.fairPreparationStep_strengthens ZFSet.omega E0 stages U enumSelector prepSelector
grid packed s.carrier s.conditionOrder nodes T selected
(clocks k) (s.encode (seq k)) (births k) (events k)
(clocks (k + 1)) (s.encode (seq (k + 1))) (births (k + 1)) (events (k + 1))
((s.pair_mem_conditionOrder _ _).2 le_rfl) (rawSteps k)
exact ⟨seq, s.injective zeroCondition,
M.decoded_function_graph_mem natPresentation s graphGround graphFunction, decreasing,
clocks, births, events, zeroClock, zeroTail.1, zeroTail.2, entries, rawSteps⟩
end PartitionPilot.Forcing.TransitiveGround
end
end OAI
|