openAI-math-dataset / lean /OAI /SetTheory /PartitionPrinciple /Transfinite /CompressionPrefixCoinitiality.lean
| import OAI.SetTheory.PartitionPrinciple.Transfinite.GroundChronologyFieldAppend | |
| namespace OAI | |
| namespace PartitionPilot.Forcing.GroundCompressionState | |
| open SetFormula SetRealization | |
| universe u | |
| variable {M : TransitiveGround.{u}} | |
| variable {P0 r0 μ0 A0 τ I Sources Reps G m inv one T Filters : ZFSet.{u}} | |
| variable {seed : FixedCompressionSeed P0 r0 μ0 A0 τ I Sources Reps G m inv one T Filters} | |
| variable (state : GroundCompressionState M seed) | |
| variable (pairing : Realize M.sets SetFormula.pairing Fin.elim0) | |
| variable (unions : Realize M.sets SetFormula.union Fin.elim0) | |
| variable (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets) | |
| include pairing unions powers separation | |
| noncomputable def incoming_birth_layer_of_constancy | |
| (constant : RecursiveTemplateConstancy P0 r0 μ0 state.data) | |
| {Space sourceOrder sourceMeet : ZFSet.{u} → ZFSet.{u}} | |
| {base birth bound stamp : ZFSet.{u}} | |
| (born : ZFSet.IsFunc state.data.D bound birth) | |
| (old : ∀ x t, ZFSet.pair x t ∈ birth → t ∈ stamp) | |
| (before : base ∈ stamp) | |
| (space : Space base = P0) (order : sourceOrder base = r0) (meet : sourceMeet base = μ0) : | |
| CodedGrowthLayer M Space sourceOrder sourceMeet state.data.currentCarrier | |
| state.data.currentOrder state.data.currentMeet (state.batch.batchBirth birth stamp) stamp := by | |
| apply state.batch.batchBirth_incoming_layer pairing unions powers separation | |
| state.ground.carrier state.ground.indices state.ground.spaces state.ground.relations | |
| state.ground.anchors state.ground.embeddings born old (fun _ => base) (fun _ => before) | |
| · intro i | |
| exact space.trans ((constant.space_entry_iff _ _).1 | |
| (state.batch.space_entry ⟨SetMembers.raw i, SetMembers.raw_mem i⟩)).2.symm | |
| · intro i | |
| exact order.trans ((constant.relation_entry_iff _ _).1 | |
| (state.batch.rel_entry ⟨SetMembers.raw i, SetMembers.raw_mem i⟩)).2.symm | |
| · intro i | |
| exact meet.trans ((constant.meet_entry_iff _ _).1 | |
| (state.batch.meet_entry ⟨SetMembers.raw i, SetMembers.raw_mem i⟩)).2.symm | |
| variable (data : GroundCompressionUnionData M state.data I Sources Reps G m one T) | |
| variable (hI : I ∈ M.sets) (hSources : Sources ∈ M.sets) (hReps : Reps ∈ M.sets) | |
| variable (hG : G ∈ M.sets) (hT : T ∈ M.sets) | |
| include hI hSources hReps hG hT | |
| noncomputable def canonical_incoming_birth_layer | |
| (constant : RecursiveTemplateConstancy P0 r0 μ0 state.data) | |
| {Space sourceOrder sourceMeet : ZFSet.{u} → ZFSet.{u}} | |
| {base stamps limit old birth : ZFSet.{u}} | |
| (code : NatBirthExtensionCode (fun n => (state.data.iterate M I Sources Reps G T n).D) | |
| (compressionStamp base) old birth) | |
| (born : ZFSet.IsFunc state.data.D limit old) | |
| (times : CompressionStampCode base stamps limit) | |
| (oldBound : ∀ x t, ZFSet.pair x t ∈ old → t ∈ base ∨ t = base) | |
| (space : Space base = P0) (order : sourceOrder base = r0) (meet : sourceMeet base = μ0) | |
| (n : Nat) : | |
| CodedGrowthLayer M Space sourceOrder sourceMeet | |
| (state.data.iterate M I Sources Reps G T n).currentCarrier | |
| (state.data.iterate M I Sources Reps G T n).currentOrder | |
| (state.data.iterate M I Sources Reps G T n).currentMeet | |
| (graphRestriction (state.data.iterate M I Sources Reps G T (n + 1)).D birth) | |
| (compressionStamp base n) := by | |
| let current := state.iterate pairing unions powers separation hI hSources hReps hG hT n | |
| have equal : current.data = state.data.iterate M I Sources Reps G T n := | |
| state.iterate_data pairing unions powers separation hI hSources hReps hG hT n | |
| have currentConstant : RecursiveTemplateConstancy P0 r0 μ0 current.data := by | |
| simpa only [equal] using constant.iterate M I Sources Reps G T n | |
| have finite : ZFSet.IsFunc current.data.D limit | |
| (graphRestriction (state.data.iterate M I Sources Reps G T n).D birth) := by | |
| simpa only [equal] using state.canonical_birth_function data pairing unions powers separation | |
| hI hSources hReps hG hT code born times n | |
| have earlier : ∀ x t, ZFSet.pair x t ∈ | |
| graphRestriction (state.data.iterate M I Sources Reps G T n).D birth → t ∈ compressionStamp base n := | |
| fun _ _ entry => state.canonical_birth_before_stamp pairing unions powers separation | |
| hI hSources hReps hG hT code oldBound n entry | |
| have result := current.incoming_birth_layer_of_constancy pairing unions powers separation | |
| currentConstant finite earlier (compressionStamp_base_mem base n) space order meet | |
| change CodedGrowthLayer M Space sourceOrder sourceMeet current.data.currentCarrier | |
| current.data.currentOrder current.data.currentMeet | |
| (taggedBirth current.data.D current.data.fresh | |
| (graphRestriction (state.data.iterate M I Sources Reps G T n).D birth) | |
| (compressionStamp base n)) (compressionStamp base n) at result | |
| rw [state.canonical_birth_step pairing unions powers separation hI hSources hReps hG hT code born n] | |
| simpa only [equal] using result | |
| end PartitionPilot.Forcing.GroundCompressionState | |
| namespace PartitionPilot.Forcing.GroundCompressionState | |
| open SetFormula | |
| universe u | |
| variable {M : TransitiveGround.{u}} | |
| variable {P0 r0 μ0 A0 τ I Sources Reps G m inv one T Filters : ZFSet.{u}} | |
| variable {seed : FixedCompressionSeed P0 r0 μ0 A0 τ I Sources Reps G m inv one T Filters} | |
| variable (state : GroundCompressionState M seed) | |
| variable (data : GroundCompressionUnionData M state.data I Sources Reps G m one T) | |
| variable {base old : ZFSet.{u}} | |
| variable (births : GroundCompressionBirthData M state.data I Sources Reps G m one T data base old) | |
| variable {Space sourceOrder sourceMeet : ZFSet.{u} → ZFSet.{u}} | |
| variable (pairing : Realize M.sets SetFormula.pairing Fin.elim0) | |
| variable (unions : Realize M.sets SetFormula.union Fin.elim0) | |
| variable (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets) | |
| variable (hI : I ∈ M.sets) (hSources : Sources ∈ M.sets) (hReps : Reps ∈ M.sets) | |
| variable (hG : G ∈ M.sets) (hT : T ∈ M.sets) | |
| include pairing unions powers separation hI hSources hReps hG hT | |
| noncomputable def ground_birth_incoming_layer | |
| (constant : RecursiveTemplateConstancy P0 r0 μ0 state.data) | |
| (space : Space base = P0) (order : sourceOrder base = r0) (meet : sourceMeet base = μ0) | |
| (n : Nat) : | |
| CodedGrowthLayer M Space sourceOrder sourceMeet (data.fields 0) (data.fields 1) | |
| (data.fields 2) births.birth (compressionStamp base n) := | |
| state.canonical_birth_layer_to_union data pairing unions powers separation | |
| hI hSources hReps hG hT births.extension births.initial_function (n + 1) | |
| ((compressionStamp_mem_iff base n (n + 1)).2 (Nat.lt_succ_self n)) | |
| (state.canonical_incoming_birth_layer pairing unions powers separation data | |
| hI hSources hReps hG hT constant births.extension births.initial_function births.times | |
| births.initial_bound space order meet n) | |
| noncomputable def ground_birth_prior_layer {t : ZFSet.{u}} (priorTime : t ∈ base ∨ t = base) | |
| (layer : CodedGrowthLayer M Space sourceOrder sourceMeet state.data.D state.data.rD state.data.μD old t) : | |
| CodedGrowthLayer M Space sourceOrder sourceMeet (data.fields 0) (data.fields 1) | |
| (data.fields 2) births.birth t := | |
| state.prior_birth_layer_to_union data pairing unions powers separation | |
| hI hSources hReps hG hT births.extension births.initial_function priorTime layer | |
| omit pairing unions powers separation hI hSources hReps hG hT in | |
| def ground_birth_limit_layer : | |
| CodedGrowthLayer M Space sourceOrder sourceMeet (data.fields 0) (data.fields 1) | |
| (data.fields 2) births.birth births.limit := | |
| .empty_of_no_birth ⟨data.fields 0, data.ground 0⟩ (fun x _ => births.no_limit_birth x) | |
| end PartitionPilot.Forcing.GroundCompressionState | |
| namespace PartitionPilot.Forcing.GroundCompressionState | |
| open SetFormula | |
| universe u | |
| variable {M : TransitiveGround.{u}} | |
| variable {P0 r0 μ0 A0 τ I Sources Reps G m inv one T Filters : ZFSet.{u}} | |
| variable {seed : FixedCompressionSeed P0 r0 μ0 A0 τ I Sources Reps G m inv one T Filters} | |
| variable (state : GroundCompressionState M seed) | |
| variable (pairing : Realize M.sets SetFormula.pairing Fin.elim0) | |
| variable (unions : Realize M.sets SetFormula.union Fin.elim0) | |
| variable (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets) | |
| variable (hI : I ∈ M.sets) (hSources : Sources ∈ M.sets) (hReps : Reps ∈ M.sets) | |
| variable (hG : G ∈ M.sets) (hT : T ∈ M.sets) | |
| variable {Space sourceOrder sourceMeet : ZFSet.{u} → ZFSet.{u}} | |
| include pairing unions powers separation hI hSources hReps hG hT | |
| section Transfer | |
| variable {base limit old birth : ZFSet.{u}} | |
| variable (code : NatBirthExtensionCode (fun n => (state.data.iterate M I Sources Reps G T n).D) | |
| (compressionStamp base) old birth) | |
| variable (born : ZFSet.IsFunc state.data.D limit old) | |
| include code born | |
| noncomputable def canonical_birth_layer_to_finite (n k : Nat) (before : n ≤ k) | |
| {t : ZFSet.{u}} (earlier : t ∈ compressionStamp base n) | |
| (layer : CodedGrowthLayer M Space sourceOrder sourceMeet | |
| (state.data.iterate M I Sources Reps G T n).D | |
| (state.data.iterate M I Sources Reps G T n).rD | |
| (state.data.iterate M I Sources Reps G T n).μD | |
| (graphRestriction (state.data.iterate M I Sources Reps G T n).D birth) t) : | |
| CodedGrowthLayer M Space sourceOrder sourceMeet | |
| (state.data.iterate M I Sources Reps G T k).D | |
| (state.data.iterate M I Sources Reps G T k).rD | |
| (state.data.iterate M I Sources Reps G T k).μD | |
| (graphRestriction (state.data.iterate M I Sources Reps G T k).D birth) t := by | |
| have mono := fun n k h => (state.canonical_iterate_graphs_mono pairing unions powers separation | |
| hI hSources hReps hG hT (n := n) (k := k) h).1 | |
| have growth := state.canonical_iterate_graphs_mono pairing unions powers separation | |
| hI hSources hReps hG hT before | |
| have ground : (state.data.iterate M I Sources Reps G T n).D ∈ M.sets := by | |
| obtain ⟨current, equal⟩ := state.canonical_iterate_valid pairing unions powers separation | |
| hI hSources hReps hG hT n | |
| rw [← equal] | |
| exact current.ground.carrier | |
| exact layer.of_literal_extension separation ground growth.1 growth.2.1 growth.2.2.1 | |
| (NatBirthExtensionCode.restriction_mono mono before) | |
| (fun _ _ entry => code.earlier_fiber mono born | |
| (fun _ _ h => compressionStamp_subset base h) n earlier | |
| (pair_mem_graphRestriction.1 entry).1) | |
| noncomputable def prior_birth_layer_to_finite (k : Nat) {t : ZFSet.{u}} | |
| (priorTime : t ∈ base ∨ t = base) | |
| (layer : CodedGrowthLayer M Space sourceOrder sourceMeet | |
| state.data.D state.data.rD state.data.μD old t) : | |
| CodedGrowthLayer M Space sourceOrder sourceMeet | |
| (state.data.iterate M I Sources Reps G T k).D | |
| (state.data.iterate M I Sources Reps G T k).rD | |
| (state.data.iterate M I Sources Reps G T k).μD | |
| (graphRestriction (state.data.iterate M I Sources Reps G T k).D birth) t := by | |
| have mono := fun n k h => (state.canonical_iterate_graphs_mono pairing unions powers separation | |
| hI hSources hReps hG hT (n := n) (k := k) h).1 | |
| have zero := code.restriction_zero mono born | |
| apply state.canonical_birth_layer_to_finite pairing unions powers separation | |
| hI hSources hReps hG hT code born 0 k (Nat.zero_le k) (compressionStamp_old_mem priorTime 0) | |
| rw [zero] | |
| simpa only [RecursiveStateData.iterate_zero] using layer | |
| end Transfer | |
| noncomputable def ground_birth_finite_all_layers | |
| (data : GroundCompressionUnionData M state.data I Sources Reps G m one T) | |
| {base old : ZFSet.{u}} | |
| (births : GroundCompressionBirthData M state.data I Sources Reps G m one T data base old) | |
| (constant : RecursiveTemplateConstancy P0 r0 μ0 state.data) | |
| (space : Space base = P0) (order : sourceOrder base = r0) (meet : sourceMeet base = μ0) | |
| (prior : ∀ t, t ∈ base ∨ t = base → | |
| CodedGrowthLayer M Space sourceOrder sourceMeet state.data.D state.data.rD state.data.μD old t) | |
| (n : Nat) (t : ZFSet.{u}) (bound : t ∈ compressionStamp base n ∨ t = compressionStamp base n) : | |
| CodedGrowthLayer M Space sourceOrder sourceMeet | |
| (state.data.iterate M I Sources Reps G T (n + 1)).D | |
| (state.data.iterate M I Sources Reps G T (n + 1)).rD | |
| (state.data.iterate M I Sources Reps G T (n + 1)).μD | |
| (graphRestriction (state.data.iterate M I Sources Reps G T (n + 1)).D births.birth) t := by | |
| have cases : t ∈ base ∨ t = base ∨ ∃ j, j ≤ n ∧ t = compressionStamp base j := by | |
| rcases bound with before | equal | |
| · rcases (mem_compressionStamp_iff base t n).1 before with old | equal | ⟨j, before, equal⟩ | |
| · exact Or.inl old | |
| · exact Or.inr (Or.inl equal) | |
| · exact Or.inr (Or.inr ⟨j, Nat.le_of_lt before, equal⟩) | |
| · exact Or.inr (Or.inr ⟨n, Nat.le_refl n, equal⟩) | |
| apply Classical.choice | |
| rcases cases with old | equal | ⟨j, before, rfl⟩ | |
| · exact ⟨state.prior_birth_layer_to_finite pairing unions powers separation | |
| hI hSources hReps hG hT births.extension births.initial_function (n + 1) | |
| (Or.inl old) (prior t (Or.inl old))⟩ | |
| · exact ⟨state.prior_birth_layer_to_finite pairing unions powers separation | |
| hI hSources hReps hG hT births.extension births.initial_function (n + 1) | |
| (Or.inr equal) (prior t (Or.inr equal))⟩ | |
| · exact ⟨state.canonical_birth_layer_to_finite pairing unions powers separation | |
| hI hSources hReps hG hT births.extension births.initial_function (j + 1) (n + 1) | |
| (Nat.add_le_add_right before 1) | |
| ((compressionStamp_mem_iff base j (j + 1)).2 (Nat.lt_succ_self j)) | |
| (state.canonical_incoming_birth_layer pairing unions powers separation data | |
| hI hSources hReps hG hT constant births.extension births.initial_function births.times | |
| births.initial_bound space order meet j)⟩ | |
| end PartitionPilot.Forcing.GroundCompressionState | |
| namespace PartitionPilot.Forcing.GroundCompressionState | |
| open SetFormula | |
| universe u | |
| variable {M : TransitiveGround.{u}} | |
| variable {P0 r0 μ0 A0 τ I Sources Reps G m inv one T Filters : ZFSet.{u}} | |
| variable {seed : FixedCompressionSeed P0 r0 μ0 A0 τ I Sources Reps G m inv one T Filters} | |
| variable (state : GroundCompressionState M seed) | |
| variable (data : GroundCompressionUnionData M state.data I Sources Reps G m one T) | |
| variable {base old : ZFSet.{u}} | |
| variable (births : GroundCompressionBirthData M state.data I Sources Reps G m one T data base old) | |
| noncomputable def ground_birth_all_layers | |
| (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) | |
| (hI : I ∈ M.sets) (hSources : Sources ∈ M.sets) (hReps : Reps ∈ M.sets) | |
| (hG : G ∈ M.sets) (hT : T ∈ M.sets) | |
| (constant : RecursiveTemplateConstancy P0 r0 μ0 state.data) | |
| {Space sourceOrder sourceMeet : ZFSet.{u} → ZFSet.{u}} | |
| (space : Space base = P0) (order : sourceOrder base = r0) (meet : sourceMeet base = μ0) | |
| (prior : ∀ t, t ∈ base ∨ t = base → | |
| CodedGrowthLayer M Space sourceOrder sourceMeet state.data.D state.data.rD state.data.μD old t) | |
| (t : ZFSet.{u}) (bound : t ∈ births.limit ∨ t = births.limit) : | |
| CodedGrowthLayer M Space sourceOrder sourceMeet (data.fields 0) (data.fields 1) | |
| (data.fields 2) births.birth t := by | |
| apply Classical.choice | |
| rcases bound with before | rfl | |
| · rcases (births.times.mem_limit_iff t).1 before with original | same | ⟨n, rfl⟩ | |
| · exact ⟨state.ground_birth_prior_layer data births pairing unions powers separation | |
| hI hSources hReps hG hT (Or.inl original) (prior t (Or.inl original))⟩ | |
| · exact ⟨state.ground_birth_prior_layer data births pairing unions powers separation | |
| hI hSources hReps hG hT (Or.inr same) (prior t (Or.inr same))⟩ | |
| · exact ⟨state.ground_birth_incoming_layer data births pairing unions powers separation | |
| hI hSources hReps hG hT constant space order meet n⟩ | |
| · exact ⟨state.ground_birth_limit_layer data births⟩ | |
| end PartitionPilot.Forcing.GroundCompressionState | |
| namespace PartitionPilot.Forcing.GroundCompressionState | |
| open SetFormula | |
| universe u | |
| variable {M : TransitiveGround.{u}} | |
| variable {P0 r0 μ0 A0 τ I Sources Reps G m inv one T Filters : ZFSet.{u}} | |
| variable {seed : FixedCompressionSeed P0 r0 μ0 A0 τ I Sources Reps G m inv one T Filters} | |
| variable (state : GroundCompressionState M seed) | |
| variable (data : GroundCompressionUnionData M state.data I Sources Reps G m one T) | |
| variable {base old T0 C Q qlt original : ZFSet.{u}} | |
| variable (births : GroundCompressionBirthData M state.data I Sources Reps G m one T data base old) | |
| variable (heights : GroundCompressionHeightData M state.data I Sources Reps G m one T | |
| data P0 C Q qlt original) | |
| variable (prior : GroundChronologicalHistory M T0 C Q qlt) | |
| theorem prefix_sources_eq_below {t s : ZFSet.{u}} (oldTime : t ∈ base ∨ t = base) | |
| (before : s ∈ t) : | |
| (state.prefixFields data births heights prior).space s = prior.space s ∧ (state.prefixFields data births heights prior).order s = prior.order s ∧ | |
| (state.prefixFields data births heights prior).meetGraph s = prior.meetGraph s := by | |
| dsimp only [prefixFields] | |
| exact ⟨compressionPrefixValue_eq_prior_below _ _ _ births.times oldTime before, | |
| compressionPrefixValue_eq_prior_below _ _ _ births.times oldTime before, | |
| compressionPrefixValue_eq_prior_below _ _ _ births.times oldTime before⟩ | |
| variable (ordinal : ordinalSetProperty T0) (hBase : base ∈ T0) | |
| include ordinal hBase | |
| noncomputable def prefix_old_layer {cutoff t : ZFSet.{u}} | |
| (oldCutoff : cutoff ∈ base ∨ cutoff = base) (bound : t = cutoff ∨ t ∈ cutoff) : | |
| CodedGrowthLayer M (state.prefixFields data births heights prior).space (state.prefixFields data births heights prior).order (state.prefixFields data births heights prior).meetGraph | |
| ((state.prefixFields data births heights prior).space cutoff) ((state.prefixFields data births heights prior).order cutoff) ((state.prefixFields data births heights prior).meetGraph cutoff) ((state.prefixFields data births heights prior).birth cutoff) t := by | |
| have hc : cutoff ∈ T0 := oldCutoff.elim | |
| (fun member => ordinal.1 base hBase cutoff member) (fun equal => equal.symm ▸ hBase) | |
| have ht : t ∈ T0 := bound.elim (fun equal => equal.symm ▸ hc) | |
| (fun before => ordinal.1 cutoff hc t before) | |
| have oldTime : t ∈ base ∨ t = base := by | |
| rcases bound with equal | before | |
| · exact equal.symm ▸ oldCutoff | |
| · apply Or.inl | |
| rcases oldCutoff with member | equal | |
| · exact ordinal.2 base hBase cutoff member t before | |
| · exact equal ▸ before | |
| have layer := (prior.layer cutoff hc t ht bound).congr_sources_below | |
| (fun s hs => (state.prefix_sources_eq_below data births heights prior oldTime hs).1.symm) | |
| (fun s hs => (state.prefix_sources_eq_below data births heights prior oldTime hs).2.1.symm) | |
| (fun s hs => (state.prefix_sources_eq_below data births heights prior oldTime hs).2.2.symm) | |
| have values := state.prefixFields_old data births heights prior oldCutoff | |
| simpa only [values.1, values.2.1, values.2.2.1, values.2.2.2.1] using layer | |
| variable (initialDomain : state.data.D = P0) (initialOrder : state.data.rD = r0) | |
| variable (initialMeet : state.data.μD = μ0) | |
| variable (priorSpace : prior.space base = P0) (priorOrder : prior.order base = r0) | |
| variable (priorMeet : prior.meetGraph base = μ0) (priorBirth : prior.birth base = old) | |
| include initialDomain initialOrder initialMeet priorSpace priorOrder priorMeet priorBirth | |
| noncomputable def prefix_base_layers (t : ZFSet.{u}) (before : t ∈ base ∨ t = base) : | |
| CodedGrowthLayer M (state.prefixFields data births heights prior).space (state.prefixFields data births heights prior).order (state.prefixFields data births heights prior).meetGraph | |
| state.data.D state.data.rD state.data.μD old t := by | |
| have layer := state.prefix_old_layer data births heights prior ordinal hBase | |
| (Or.inr rfl : base ∈ base ∨ base = base) before.symm | |
| have values := state.prefixFields_old data births heights prior (Or.inr rfl : base ∈ base ∨ base = base) | |
| simpa only [values.1, values.2.1, values.2.2.1, values.2.2.2.1, | |
| priorSpace, priorOrder, priorMeet, priorBirth, initialDomain, initialOrder, initialMeet] using layer | |
| variable (pairing : Realize M.sets SetFormula.pairing Fin.elim0) | |
| variable (unions : Realize M.sets SetFormula.union Fin.elim0) | |
| variable (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets) | |
| variable (hI : I ∈ M.sets) (hSources : Sources ∈ M.sets) (hReps : Reps ∈ M.sets) | |
| variable (hG : G ∈ M.sets) (hT : T ∈ M.sets) | |
| variable (constant : RecursiveTemplateConstancy P0 r0 μ0 state.data) | |
| include pairing unions powers separation hI hSources hReps hG hT constant | |
| noncomputable def prefix_finite_layers (n : Nat) (t : ZFSet.{u}) | |
| (bound : t = compressionStamp base n ∨ t ∈ compressionStamp base n) : | |
| CodedGrowthLayer M (state.prefixFields data births heights prior).space (state.prefixFields data births heights prior).order (state.prefixFields data births heights prior).meetGraph | |
| ((state.prefixFields data births heights prior).space (compressionStamp base n)) ((state.prefixFields data births heights prior).order (compressionStamp base n)) | |
| ((state.prefixFields data births heights prior).meetGraph (compressionStamp base n)) ((state.prefixFields data births heights prior).birth (compressionStamp base n)) t := by | |
| have atBase := state.prefixFields_old data births heights prior (Or.inr rfl : base ∈ base ∨ base = base) | |
| have layer := state.ground_birth_finite_all_layers pairing unions powers separation | |
| hI hSources hReps hG hT data births constant | |
| (atBase.1.trans priorSpace) (atBase.2.1.trans priorOrder) (atBase.2.2.1.trans priorMeet) | |
| (state.prefix_base_layers data births heights prior ordinal hBase initialDomain initialOrder | |
| initialMeet priorSpace priorOrder priorMeet priorBirth) n t bound.symm | |
| have values := state.prefixFields_stamp data births heights prior n | |
| simpa only [values.1, values.2.1, values.2.2.1, values.2.2.2.1] using layer | |
| noncomputable def prefix_union_layers (t : ZFSet.{u}) | |
| (bound : t = births.limit ∨ t ∈ births.limit) : | |
| CodedGrowthLayer M (state.prefixFields data births heights prior).space (state.prefixFields data births heights prior).order (state.prefixFields data births heights prior).meetGraph | |
| ((state.prefixFields data births heights prior).space births.limit) ((state.prefixFields data births heights prior).order births.limit) | |
| ((state.prefixFields data births heights prior).meetGraph births.limit) ((state.prefixFields data births heights prior).birth births.limit) t := by | |
| have atBase := state.prefixFields_old data births heights prior (Or.inr rfl : base ∈ base ∨ base = base) | |
| have layer := state.ground_birth_all_layers data births pairing unions powers separation | |
| hI hSources hReps hG hT constant | |
| (atBase.1.trans priorSpace) (atBase.2.1.trans priorOrder) (atBase.2.2.1.trans priorMeet) | |
| (state.prefix_base_layers data births heights prior ordinal hBase initialDomain initialOrder | |
| initialMeet priorSpace priorOrder priorMeet priorBirth) t bound.symm | |
| have values := state.prefixFields_limit data births heights prior | |
| simpa only [values.1, values.2.1, values.2.2.1, values.2.2.2.1] using layer | |
| noncomputable def prefix_all_layers : | |
| ∀ cutoff ∈ insert births.limit births.limit, ∀ t ∈ insert births.limit births.limit, | |
| t = cutoff ∨ t ∈ cutoff → CodedGrowthLayer M (state.prefixFields data births heights prior).space (state.prefixFields data births heights prior).order (state.prefixFields data births heights prior).meetGraph | |
| ((state.prefixFields data births heights prior).space cutoff) ((state.prefixFields data births heights prior).order cutoff) ((state.prefixFields data births heights prior).meetGraph cutoff) ((state.prefixFields data births heights prior).birth cutoff) t := by | |
| intro cutoff hc t _ bound | |
| apply Classical.choice | |
| rcases ZFSet.mem_insert_iff.1 hc with equal | before | |
| · subst cutoff | |
| exact ⟨state.prefix_union_layers data births heights prior ordinal hBase initialDomain initialOrder | |
| initialMeet priorSpace priorOrder priorMeet priorBirth pairing unions powers separation | |
| hI hSources hReps hG hT constant t bound⟩ | |
| · rcases (births.times.mem_limit_iff cutoff).1 before with oldTime | same | ⟨n, rfl⟩ | |
| · exact ⟨state.prefix_old_layer data births heights prior ordinal hBase (Or.inl oldTime) bound⟩ | |
| · exact ⟨state.prefix_old_layer data births heights prior ordinal hBase (Or.inr same) bound⟩ | |
| · exact ⟨state.prefix_finite_layers data births heights prior ordinal hBase initialDomain initialOrder | |
| initialMeet priorSpace priorOrder priorMeet priorBirth pairing unions powers separation | |
| hI hSources hReps hG hT constant n t bound⟩ | |
| end PartitionPilot.Forcing.GroundCompressionState | |
| namespace PartitionPilot.Forcing.GroundCompressionState | |
| open SetFormula | |
| universe u | |
| variable {M : TransitiveGround.{u}} | |
| variable {P0 r0 μ0 A0 τ I Sources Reps G m inv one T Filters : ZFSet.{u}} | |
| variable {seed : FixedCompressionSeed P0 r0 μ0 A0 τ I Sources Reps G m inv one T Filters} | |
| variable (state : GroundCompressionState M seed) | |
| variable (data : GroundCompressionUnionData M state.data I Sources Reps G m one T) | |
| variable {base old T0 C Q qlt original : ZFSet.{u}} | |
| variable (births : GroundCompressionBirthData M state.data I Sources Reps G m one T data base old) | |
| variable (heights : GroundCompressionHeightData M state.data I Sources Reps G m one T data P0 C Q qlt original) | |
| variable (prior : GroundChronologicalHistory M T0 C Q qlt) | |
| variable (pairing : Realize M.sets SetFormula.pairing Fin.elim0) | |
| variable (unions : Realize M.sets SetFormula.union Fin.elim0) | |
| variable (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets) | |
| variable (hI : I ∈ M.sets) (hSources : Sources ∈ M.sets) (hReps : Reps ∈ M.sets) | |
| variable (hG : G ∈ M.sets) (hT : T ∈ M.sets) | |
| variable (ordinal : ordinalSetProperty T0) (hBase : base ∈ T0) | |
| variable (constant : RecursiveTemplateConstancy P0 r0 μ0 state.data) | |
| variable (initialDomain : state.data.D = P0) (initialOrder : state.data.rD = r0) | |
| variable (initialMeet : state.data.μD = μ0) | |
| variable (priorSpace : prior.space base = P0) (priorOrder : prior.order base = r0) | |
| variable (priorMeet : prior.meetGraph base = μ0) (priorBirth : prior.birth base = old) | |
| noncomputable def prefixHistory : | |
| GroundChronologicalHistory M (insert births.limit births.limit) C Q qlt where | |
| space := (state.prefixFields data births heights prior).space | |
| order := (state.prefixFields data births heights prior).order | |
| meetGraph := (state.prefixFields data births heights prior).meetGraph | |
| birth := (state.prefixFields data births heights prior).birth | |
| height := (state.prefixFields data births heights prior).height | |
| space_mem := fun _ hs => (state.prefixFields_ground data births heights prior | |
| pairing unions powers separation hI hSources hReps hG hT ordinal hBase hs).1 | |
| order_mem := fun _ hs => (state.prefixFields_ground data births heights prior | |
| pairing unions powers separation hI hSources hReps hG hT ordinal hBase hs).2.1 | |
| meet_mem := fun _ hs => (state.prefixFields_ground data births heights prior | |
| pairing unions powers separation hI hSources hReps hG hT ordinal hBase hs).2.2.1 | |
| birth_mem := fun _ hs => (state.prefixFields_ground data births heights prior | |
| pairing unions powers separation hI hSources hReps hG hT ordinal hBase hs).2.2.2.1 | |
| height_mem := fun _ hs => (state.prefixFields_ground data births heights prior | |
| pairing unions powers separation hI hSources hReps hG hT ordinal hBase hs).2.2.2.2 | |
| meet_order := fun _ hs => (state.prefixFields_stage_laws data births heights prior | |
| pairing unions powers separation hI hSources hReps hG hT ordinal hBase hs).1 | |
| birth_function := fun _ hs => (state.prefixFields_stage_laws data births heights prior | |
| pairing unions powers separation hI hSources hReps hG hT ordinal hBase hs).2.1 | |
| birth_bound := fun _ hs => (state.prefixFields_stage_laws data births heights prior | |
| pairing unions powers separation hI hSources hReps hG hT ordinal hBase hs).2.2.1 | |
| old_meet := fun _ hs => (state.prefixFields_stage_laws data births heights prior | |
| pairing unions powers separation hI hSources hReps hG hT ordinal hBase hs).2.2.2.1 | |
| strict_height := fun _ hs => (state.prefixFields_stage_laws data births heights prior | |
| pairing unions powers separation hI hSources hReps hG hT ordinal hBase hs).2.2.2.2 | |
| layer := state.prefix_all_layers data births heights prior ordinal hBase initialDomain initialOrder | |
| initialMeet priorSpace priorOrder priorMeet priorBirth pairing unions powers separation | |
| hI hSources hReps hG hT constant | |
| local notation "history" => state.prefixHistory data births heights prior pairing unions powers separation | |
| hI hSources hReps hG hT ordinal hBase constant initialDomain initialOrder initialMeet | |
| priorSpace priorOrder priorMeet priorBirth | |
| theorem prefixHistory_old {s : ZFSet.{u}} (before : s ∈ base ∨ s = base) : | |
| (history).space s = prior.space s ∧ (history).order s = prior.order s ∧ | |
| (history).meetGraph s = prior.meetGraph s ∧ (history).birth s = prior.birth s ∧ | |
| (history).height s = prior.height s := | |
| state.prefixFields_old data births heights prior before | |
| theorem prefixHistory_stamp (n : Nat) : | |
| (history).space (compressionStamp base n) = (state.data.iterate M I Sources Reps G T (n + 1)).D ∧ | |
| (history).order (compressionStamp base n) = (state.data.iterate M I Sources Reps G T (n + 1)).rD ∧ | |
| (history).meetGraph (compressionStamp base n) = (state.data.iterate M I Sources Reps G T (n + 1)).μD ∧ | |
| (history).birth (compressionStamp base n) = | |
| graphRestriction (state.data.iterate M I Sources Reps G T (n + 1)).D births.birth ∧ | |
| (history).height (compressionStamp base n) = heights.function.natValue (n + 1) := | |
| state.prefixFields_stamp data births heights prior n | |
| theorem prefixHistory_limit : | |
| (history).space births.limit = data.fields 0 ∧ (history).order births.limit = data.fields 1 ∧ | |
| (history).meetGraph births.limit = data.fields 2 ∧ (history).birth births.limit = births.birth ∧ | |
| (history).height births.limit = heights.height := | |
| state.prefixFields_limit data births heights prior | |
| end PartitionPilot.Forcing.GroundCompressionState | |
| namespace PartitionPilot.Forcing.GroundCompressionState | |
| open SetFormula | |
| universe u | |
| variable {M N : TransitiveGround.{u}} | |
| variable {P0 r0 μ0 A0 τ I Sources Reps G m inv one T Filters : ZFSet.{u}} | |
| variable {seed : FixedCompressionSeed P0 r0 μ0 A0 τ I Sources Reps G m inv one T Filters} | |
| variable (state : GroundCompressionState M seed) | |
| variable (data : GroundCompressionUnionData M state.data I Sources Reps G m one T) | |
| variable {base old T0 C Q qlt original : ZFSet.{u}} | |
| variable (births : GroundCompressionBirthData M state.data I Sources Reps G m one T data base old) | |
| variable (heights : GroundCompressionHeightData M state.data I Sources Reps G m one T | |
| data P0 C Q qlt original) | |
| variable (prior : GroundChronologicalHistory M T0 C Q qlt) | |
| variable (pairing : Realize M.sets SetFormula.pairing Fin.elim0) | |
| variable (unions : Realize M.sets SetFormula.union Fin.elim0) | |
| variable (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets) | |
| variable (hI : I ∈ M.sets) (hSources : Sources ∈ M.sets) (hReps : Reps ∈ M.sets) | |
| variable (hG : G ∈ M.sets) (hT : T ∈ M.sets) | |
| variable (ordinal : ordinalSetProperty T0) (hBase : base ∈ T0) | |
| variable (constant : RecursiveTemplateConstancy P0 r0 μ0 state.data) | |
| variable (initialDomain : state.data.D = P0) (initialOrder : state.data.rD = r0) | |
| variable (initialMeet : state.data.μD = μ0) | |
| variable (priorSpace : prior.space base = P0) (priorOrder : prior.order base = r0) | |
| variable (priorMeet : prior.meetGraph base = μ0) (priorBirth : prior.birth base = old) | |
| include state data births heights prior pairing unions powers separation | |
| hI hSources hReps hG hT ordinal hBase constant initialDomain initialOrder initialMeet | |
| priorSpace priorOrder priorMeet priorBirth | |
| theorem prefix_exists_extension_basis | |
| (includes : M.sets ⊆ N.sets) | |
| (pairingN : Realize N.sets SetFormula.pairing Fin.elim0) | |
| (unionsN : Realize N.sets SetFormula.union Fin.elim0) | |
| (powersN : Realize N.sets powerSet Fin.elim0) (separationN : SeparationSchema N.sets) | |
| (infiniteN : Realize N.sets SetFormula.infinity Fin.elim0) | |
| (choiceN : Realize N.sets SetFormula.choice Fin.elim0) | |
| (hC : C ∈ M.sets) (hQ : Q ∈ M.sets) | |
| (smallQ : M.groundEmbeddable Q ZFSet.omega) | |
| (irreflexive : ∀ q ∈ Q, ZFSet.pair q q ∉ qlt) | |
| {F : ZFSet.{u}} (hF : F ∈ N.sets) | |
| (filter : MeetFilterCode (data.fields 0) (data.fields 1) (data.fields 2) F) : | |
| ∃ B ∈ N.sets, ∃ f ∈ N.sets, InjectionCode B ZFSet.omega f ∧ B ⊆ F ∧ | |
| ∀ x ∈ F, ∃ b ∈ B, ZFSet.pair b x ∈ data.fields 1 := by | |
| let history := state.prefixHistory data births heights prior pairing unions powers separation | |
| hI hSources hReps hG hT ordinal hBase constant initialDomain initialOrder initialMeet | |
| priorSpace priorOrder priorMeet priorBirth | |
| have atLimit := state.prefixHistory_limit data births heights prior pairing unions powers separation | |
| hI hSources hReps hG hT ordinal hBase constant initialDomain initialOrder initialMeet | |
| priorSpace priorOrder priorMeet priorBirth | |
| change history.space births.limit = data.fields 0 ∧ history.order births.limit = data.fields 1 ∧ | |
| history.meetGraph births.limit = data.fields 2 ∧ history.birth births.limit = births.birth ∧ | |
| history.height births.limit = heights.height at atLimit | |
| have filterAtLimit : MeetFilterCode (history.space births.limit) (history.order births.limit) | |
| (history.meetGraph births.limit) F := by | |
| simpa only [atLimit.1, atLimit.2.1, atLimit.2.2.1] using filter | |
| have basis := history.exists_extension_basis includes pairingN unionsN powersN separationN | |
| infiniteN choiceN (M.insert_mem pairing unions births.limit_ground births.limit_ground) | |
| hC hQ (ordinalSetProperty_succ births.times.ordinal) smallQ irreflexive | |
| (ZFSet.mem_insert births.limit births.limit) hF filterAtLimit | |
| simpa only [atLimit.2.1] using basis | |
| end PartitionPilot.Forcing.GroundCompressionState | |
| end OAI | |