File size: 2,911 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 | import OAI.SetTheory.PartitionPrinciple.Geometry.GrowthLayerSourceCongruence
import OAI.SetTheory.PartitionPrinciple.Geometry.TemplateHeightRangeCodes
namespace OAI
section
namespace PartitionPilot.Forcing
universe u
theorem MeetEmbeddingCode.restrictTarget {A L Q rA rL μA μL e : ZFSet.{u}}
(code : MeetEmbeddingCode A L rA rL μA μL e)
(values : ∀ x y, ZFSet.pair x y ∈ e → y ∈ Q) :
MeetEmbeddingCode A Q rA (heightOrderRestriction Q rL) μA
(graphRestriction (ZFSet.prod Q Q) μL) e := by
refine ⟨⟨⟨?_, code.injection.function.2⟩, code.injection.injective⟩, ?_, ?_⟩
· intro z hz
obtain ⟨x, hx, y, _, rfl⟩ := ZFSet.mem_prod.1 (code.injection.function.1 hz)
exact ZFSet.pair_mem_prod.2 ⟨hx, values x y hz⟩
· intro x y x' y' lower first second
exact (pair_mem_heightOrderRestriction _ _ _ _).2
⟨code.monotone x y x' y' lower first second, values x x' first, values y y' second⟩
· intro x y z x' y' z' meet first second third
exact pair_mem_graphRestriction.2
⟨code.map_meet x y z x' y' z' meet first second third,
ZFSet.pair_mem_prod.2 ⟨values x x' first, values y y' second⟩⟩
def CodedGrowthLayer.restrictBirth
{M : TransitiveGround.{u}} {Space sourceOrder sourceMeet : ZFSet.{u} → ZFSet.{u}}
{L r μ birth t : ZFSet.{u}}
(layer : CodedGrowthLayer M Space sourceOrder sourceMeet L r μ birth t)
(meet : MeetOrderCode L r μ) :
CodedGrowthLayer M Space sourceOrder sourceMeet L r μ (graphRestriction L birth) t := by
cases layer with
| countablePoints D ground small cover =>
exact .countablePoints D ground small
(fun x hx entry => cover x hx (pair_mem_graphRestriction.1 entry).1)
| copies I parts groundI small groundParts index e earlier groundCopy embedding cover inCopy =>
exact .copies I parts groundI small groundParts index e earlier groundCopy embedding
(fun x hx entry => cover x hx (pair_mem_graphRestriction.1 entry).1) inCopy
| separated I index e earlier groundCopy embedding component cover separated =>
let original (x : {x : ZFSet.{u} // x ∈ L ∧ ZFSet.pair x t ∈ graphRestriction L birth}) :
{x : ZFSet.{u} // x ∈ L ∧ ZFSet.pair x t ∈ birth} :=
⟨x.val, x.property.1, (pair_mem_graphRestriction.1 x.property.2).1⟩
refine .separated I index e earlier groundCopy embedding (fun x => component (original x))
(fun x => cover (original x)) ?_
intro x y different
rcases separated (original x) (original y) different with
⟨z, a, entry, born, before⟩ | ⟨z, hz, a, born, before, between⟩
· exact Or.inl ⟨z, a, entry, pair_mem_graphRestriction.2
⟨born, (ZFSet.pair_mem_prod.1 (meet.operation.1 entry)).2⟩, before⟩
· exact Or.inr ⟨z, hz, a, pair_mem_graphRestriction.2 ⟨born, hz⟩, before, between⟩
end PartitionPilot.Forcing
end
end OAI
|