File size: 6,555 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 | import OAI.SetTheory.PartitionPrinciple.Forcing.ActionPostcompositionCodes
namespace OAI
section
namespace PartitionPilot.Forcing
universe u
namespace MeetEmbeddingCode
variable {P L rP rL μP μL S : ZFSet.{u}}
variable (embedding : MeetEmbeddingCode P L rP rL μP μL S)
noncomputable def value (x : {x : ZFSet.{u} // x ∈ P}) :
{y : ZFSet.{u} // y ∈ L} :=
let graph : FunctionGraphOn P S := ⟨L, embedding.injection.function⟩
⟨graph.value x, (ZFSet.pair_mem_prod.1
(embedding.injection.function.1 (graph.value_entry x))).2⟩
theorem value_entry (x : {x : ZFSet.{u} // x ∈ P}) :
ZFSet.pair x.val (embedding.value x).val ∈ S :=
(show FunctionGraphOn P S from ⟨L, embedding.injection.function⟩).value_entry x
theorem value_eq_iff (x : {x : ZFSet.{u} // x ∈ P})
(y : {y : ZFSet.{u} // y ∈ L}) :
embedding.value x = y ↔ ZFSet.pair x.val y.val ∈ S := by
constructor
· intro equal
exact equal ▸ embedding.value_entry x
· intro entry
exact Subtype.ext ((show FunctionGraphOn P S from
⟨L, embedding.injection.function⟩).unique (embedding.value_entry x) entry)
noncomputable def toMeetEmbedding (source : MeetOrderCode P rP μP)
(target : MeetOrderCode L rL μL) :
MeetEmbedding source.toMeetOrder target.toMeetOrder where
toFun := embedding.value
le_iff x y := embedding.order_iff source target
(embedding.value_entry x) (embedding.value_entry y)
map_meet x y := by
apply Subtype.ext
exact (show FunctionGraphOn (ZFSet.prod L L) μL from
⟨L, target.operation⟩).unique
(embedding.map_meet _ _ _ _ _ _ (source.toMeetOrder_meet_entry x y)
(embedding.value_entry x) (embedding.value_entry y)
(embedding.value_entry (source.toMeetOrder.meet x y)))
(target.toMeetOrder_meet_entry (embedding.value x) (embedding.value y))
theorem toMeetEmbedding_entry (source : MeetOrderCode P rP μP)
(target : MeetOrderCode L rL μL) (x : {x : ZFSet.{u} // x ∈ P}) :
ZFSet.pair x.val ((embedding.toMeetEmbedding source target).toFun x).val ∈ S :=
embedding.value_entry x
theorem toMeetEmbedding_eq_iff (source : MeetOrderCode P rP μP)
(target : MeetOrderCode L rL μL) (x : {x : ZFSet.{u} // x ∈ P})
(y : {y : ZFSet.{u} // y ∈ L}) :
(embedding.toMeetEmbedding source target).toFun x = y ↔
ZFSet.pair x.val y.val ∈ S := embedding.value_eq_iff x y
end MeetEmbeddingCode
namespace PosetActionCode
variable {G P m inv e r μ A : ZFSet.{u}}
variable (action : PosetActionCode G P m e r A)
noncomputable def rawAct (g : {g : ZFSet.{u} // g ∈ G})
(x : {x : ZFSet.{u} // x ∈ P}) : {y : ZFSet.{u} // y ∈ P} :=
let graph : FunctionGraphOn (ZFSet.prod G P) A := ⟨P, action.function⟩
let input := (⟨ZFSet.pair g.val x.val,
ZFSet.pair_mem_prod.2 ⟨g.property, x.property⟩⟩ :
{z : ZFSet.{u} // z ∈ ZFSet.prod G P})
⟨graph.value input, (ZFSet.pair_mem_prod.1
(action.function.1 (graph.value_entry input))).2⟩
theorem rawAct_entry (g : {g : ZFSet.{u} // g ∈ G})
(x : {x : ZFSet.{u} // x ∈ P}) :
ZFSet.pair (ZFSet.pair g.val x.val) (action.rawAct g x).val ∈ A :=
(show FunctionGraphOn (ZFSet.prod G P) A from ⟨P, action.function⟩).value_entry
⟨ZFSet.pair g.val x.val, ZFSet.pair_mem_prod.2 ⟨g.property, x.property⟩⟩
theorem rawAct_eq_iff (g : {g : ZFSet.{u} // g ∈ G})
(x y : {x : ZFSet.{u} // x ∈ P}) :
action.rawAct g x = y ↔ ZFSet.pair (ZFSet.pair g.val x.val) y.val ∈ A := by
constructor
· intro equal
exact equal ▸ action.rawAct_entry g x
· intro entry
exact Subtype.ext ((show FunctionGraphOn (ZFSet.prod G P) A from
⟨P, action.function⟩).unique (action.rawAct_entry g x) entry)
theorem rawAct_injective (group : GroupCode G m inv e) (order : PartialOrderCode P r)
(g : {g : ZFSet.{u} // g ∈ G}) : Function.Injective (action.rawAct g) := by
intro x y equal
have lower : ZFSet.pair (action.rawAct g x).val (action.rawAct g y).val ∈ r := by
rw [equal]
exact order.refl _ (action.rawAct g y).property
have back : ZFSet.pair (action.rawAct g y).val (action.rawAct g x).val ∈ r := by
rw [equal]
exact order.refl _ (action.rawAct g y).property
exact Subtype.ext (order.antisymm x.val x.property y.val y.property
((action.raw_order_iff group order g.property
(action.rawAct_entry g x) (action.rawAct_entry g y)).1 lower)
((action.raw_order_iff group order g.property
(action.rawAct_entry g y) (action.rawAct_entry g x)).1 back))
theorem rawAct_surjective (group : GroupCode G m inv e)
(g : {g : ZFSet.{u} // g ∈ G}) : Function.Surjective (action.rawAct g) := by
intro y
obtain ⟨x, hx, entry⟩ := action.raw_preimage group g.property y.property
exact ⟨⟨x, hx⟩, (action.rawAct_eq_iff g ⟨x, hx⟩ y).2 entry⟩
noncomputable def toMeetIso (group : GroupCode G m inv e) (meet : MeetOrderCode P r μ)
(g : {g : ZFSet.{u} // g ∈ G}) :
Compression.MeetIso meet.toMeetOrder meet.toMeetOrder where
toFun := action.rawAct g
le_iff x y := action.raw_order_iff group meet.order g.property
(action.rawAct_entry g x) (action.rawAct_entry g y)
map_meet x y := by
apply Subtype.ext
exact (show FunctionGraphOn (ZFSet.prod P P) μ from ⟨P, meet.operation⟩).unique
(action.raw_map_meet group meet g.property (meet.toMeetOrder_meet_entry x y)
(action.rawAct_entry g x) (action.rawAct_entry g y)
(action.rawAct_entry g (meet.toMeetOrder.meet x y)))
(meet.toMeetOrder_meet_entry (action.rawAct g x) (action.rawAct g y))
inverse y := Classical.choose (action.rawAct_surjective group g y)
left_inverse x := action.rawAct_injective group meet.order g
(Classical.choose_spec (action.rawAct_surjective group g (action.rawAct g x)))
right_inverse y := Classical.choose_spec (action.rawAct_surjective group g y)
theorem toMeetIso_entry (group : GroupCode G m inv e) (meet : MeetOrderCode P r μ)
(g : {g : ZFSet.{u} // g ∈ G}) (x : {x : ZFSet.{u} // x ∈ P}) :
ZFSet.pair (ZFSet.pair g.val x.val)
((action.toMeetIso group meet g).toFun x).val ∈ A := action.rawAct_entry g x
theorem toMeetIso_eq_iff (group : GroupCode G m inv e) (meet : MeetOrderCode P r μ)
(g : {g : ZFSet.{u} // g ∈ G}) (x y : {x : ZFSet.{u} // x ∈ P}) :
(action.toMeetIso group meet g).toFun x = y ↔
ZFSet.pair (ZFSet.pair g.val x.val) y.val ∈ A := action.rawAct_eq_iff g x y
end PosetActionCode
end PartitionPilot.Forcing
end
end OAI
|