File size: 7,188 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 | import OAI.SetTheory.PartitionPrinciple.Definability.GroundFlatCopyGraphs
namespace OAI
section
namespace PartitionPilot.Forcing
open SetRealization
universe u
def quotientBinaryGraph (W Q classifier op : ZFSet.{u}) : ZFSet.{u} :=
ZFSet.sep (fun z => ∃ a ∈ Q, ∃ b ∈ Q, ∃ c ∈ Q,
z = ZFSet.pair (ZFSet.pair a b) c ∧
∃ x ∈ W, ∃ y ∈ W, ∃ t ∈ W,
ZFSet.pair x a ∈ classifier ∧ ZFSet.pair y b ∈ classifier ∧
ZFSet.pair t c ∈ classifier ∧ ZFSet.pair (ZFSet.pair x y) t ∈ op)
(ZFSet.prod (ZFSet.prod Q Q) Q)
theorem mem_quotientBinaryGraph (W Q classifier op z : ZFSet.{u}) :
z ∈ quotientBinaryGraph W Q classifier op ↔
∃ a ∈ Q, ∃ b ∈ Q, ∃ c ∈ Q, z = ZFSet.pair (ZFSet.pair a b) c ∧
∃ x ∈ W, ∃ y ∈ W, ∃ t ∈ W,
ZFSet.pair x a ∈ classifier ∧ ZFSet.pair y b ∈ classifier ∧
ZFSet.pair t c ∈ classifier ∧ ZFSet.pair (ZFSet.pair x y) t ∈ op := by
rw [quotientBinaryGraph, ZFSet.mem_sep]
refine ⟨And.right, ?_⟩
rintro ⟨a, ha, b, hb, c, hc, eq, rest⟩
exact ⟨eq.symm ▸ ZFSet.pair_mem_prod.2 ⟨ZFSet.pair_mem_prod.2 ⟨ha, hb⟩, hc⟩,
a, ha, b, hb, c, hc, eq, rest⟩
theorem pair_mem_quotientBinaryGraph (W Q classifier op a b c : ZFSet.{u}) :
ZFSet.pair (ZFSet.pair a b) c ∈ quotientBinaryGraph W Q classifier op ↔
a ∈ Q ∧ b ∈ Q ∧ c ∈ Q ∧ ∃ x ∈ W, ∃ y ∈ W, ∃ t ∈ W,
ZFSet.pair x a ∈ classifier ∧ ZFSet.pair y b ∈ classifier ∧
ZFSet.pair t c ∈ classifier ∧ ZFSet.pair (ZFSet.pair x y) t ∈ op := by
rw [mem_quotientBinaryGraph]
constructor
· rintro ⟨a', ha, b', hb, c', hc, eq, rest⟩
obtain ⟨ab, rfl⟩ := ZFSet.pair_inj.1 eq
obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 ab
exact ⟨ha, hb, hc, rest⟩
· rintro ⟨ha, hb, hc, rest⟩
exact ⟨a, ha, b, hb, c, hc, rfl, rest⟩
theorem quotientBinaryGraph_eq_graph {A B : Type u} (s : Presentation A) (t : Presentation B)
(q : A → B) (source : A → A → A) (target : B → B → B)
(onto : Function.Surjective q)
(compatible : ∀ x y, q (source x y) = target (q x) (q y)) :
quotientBinaryGraph s.carrier t.carrier (s.graph t q)
((s.product s).graph s (fun p => source p.1 p.2)) =
(t.product t).graph t (fun p => target p.1 p.2) := by
apply ZFSet.ext
intro z
rw [mem_quotientBinaryGraph, Presentation.mem_graph]
constructor
· rintro ⟨a, ha, b, hb, c, hc, rfl, x, hx, y, hy, w, hw, xa, yb, wc, op⟩
obtain ⟨a, rfl⟩ := (t.mem_carrier a).1 ha
obtain ⟨b, rfl⟩ := (t.mem_carrier b).1 hb
obtain ⟨c, rfl⟩ := (t.mem_carrier c).1 hc
obtain ⟨x, rfl⟩ := (s.mem_carrier x).1 hx
obtain ⟨y, rfl⟩ := (s.mem_carrier y).1 hy
obtain ⟨w, rfl⟩ := (s.mem_carrier w).1 hw
have first := (s.pair_mem_graph t q x a).1 xa
have second := (s.pair_mem_graph t q y b).1 yb
have output := (s.pair_mem_graph t q w c).1 wc
have value := ((s.product s).pair_mem_graph s (fun p => source p.1 p.2) (x, y) w).1 op
have equal : target a b = c := by
rw [← first, ← second, ← compatible, value]
exact output
exact ⟨(a, b), by change ZFSet.pair (ZFSet.pair _ _) (t.encode (target a b)) = _; rw [equal]⟩
· rintro ⟨⟨a, b⟩, rfl⟩
obtain ⟨x, rfl⟩ := onto a
obtain ⟨y, rfl⟩ := onto b
refine ⟨t.encode (q x), t.encode_mem _, t.encode (q y), t.encode_mem _,
t.encode (target (q x) (q y)), t.encode_mem _, rfl,
s.encode x, s.encode_mem _, s.encode y, s.encode_mem _,
s.encode (source x y), s.encode_mem _, ?_, ?_, ?_, ?_⟩
· exact (s.pair_mem_graph t q _ _).2 rfl
· exact (s.pair_mem_graph t q _ _).2 rfl
· exact (s.pair_mem_graph t q _ _).2 (compatible x y)
· exact ((s.product s).pair_mem_graph s (fun p => source p.1 p.2) (x, y) _).2 rfl
theorem quotientBinaryGraph_function {A B : Type u} (s : Presentation A) (t : Presentation B)
(q : A → B) (source : A → A → A) (target : B → B → B)
(onto : Function.Surjective q)
(compatible : ∀ x y, q (source x y) = target (q x) (q y)) :
ZFSet.IsFunc (ZFSet.prod t.carrier t.carrier) t.carrier
(quotientBinaryGraph s.carrier t.carrier (s.graph t q)
((s.product s).graph s (fun p => source p.1 p.2))) := by
rw [quotientBinaryGraph_eq_graph s t q source target onto compatible]
exact (t.product t).graph_isFunc t _
end PartitionPilot.Forcing
namespace PartitionPilot.Forcing
open SetFormula
universe u
namespace BoundedFormula
def quotientBinaryEntryFormula {n} (z w q classifier op : Fin n) : BoundedFormula n :=
exMem q (exMem q.succ (exMem q.succ.succ
(.conj (orderedTripleFormula z.succ.succ.succ 2 1 0)
(exMem w.succ.succ.succ (exMem w.succ.succ.succ.succ
(exMem w.succ.succ.succ.succ.succ
(.conj (pairMembershipFormula 2 5 classifier.succ.succ.succ.succ.succ.succ)
(.conj (pairMembershipFormula 1 4 classifier.succ.succ.succ.succ.succ.succ)
(.conj (pairMembershipFormula 0 3 classifier.succ.succ.succ.succ.succ.succ)
(tripleMembershipFormula 2 1 0 op.succ.succ.succ.succ.succ.succ))))))))))
theorem truth_quotientBinaryEntryFormula {n} (z w q classifier op : Fin n)
(env : Fin n → ZFSet.{u}) :
Truth (quotientBinaryEntryFormula z w q classifier op) env ↔
env z ∈ quotientBinaryGraph (env w) (env q) (env classifier) (env op) := by
simp only [quotientBinaryEntryFormula, truth_exMem, Truth, truth_orderedTripleFormula,
truth_pairMembershipFormula, truth_tripleMembershipFormula, mem_quotientBinaryGraph]
rfl
end BoundedFormula
namespace TransitiveGround
theorem quotientBinaryGraph_mem (M : TransitiveGround.{u})
(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)
{W Q classifier op : ZFSet.{u}} (hW : W ∈ M.sets) (hQ : Q ∈ M.sets)
(hc : classifier ∈ M.sets) (ho : op ∈ M.sets) :
quotientBinaryGraph W Q classifier op ∈ M.sets := by
have bound := M.prod_mem pairing unions powers separation
(M.prod_mem pairing unions powers separation hQ hQ) hQ
let params := extend W (extend Q (extend classifier (extend op Fin.elim0)))
have selected := M.bounded_separation_mem separation
(BoundedFormula.quotientBinaryEntryFormula 0 1 2 3 4) params
(Fin.cases hW (Fin.cases hQ (Fin.cases hc (Fin.cases ho (fun i => Fin.elim0 i))))) bound
have eq : ZFSet.sep (fun z => BoundedFormula.Truth
(BoundedFormula.quotientBinaryEntryFormula 0 1 2 3 4) (extend z params))
(ZFSet.prod (ZFSet.prod Q Q) Q) = quotientBinaryGraph W Q classifier op := by
apply ZFSet.ext
intro z
rw [ZFSet.mem_sep, BoundedFormula.truth_quotientBinaryEntryFormula]
change (z ∈ ZFSet.prod (ZFSet.prod Q Q) Q ∧ z ∈ quotientBinaryGraph W Q classifier op) ↔ _
exact ⟨And.right, fun hz => ⟨(ZFSet.mem_sep.1 hz).1, hz⟩⟩
exact eq ▸ selected
end TransitiveGround
end PartitionPilot.Forcing
end
end OAI
|