openAI-math-dataset / lean /OAI /SetTheory /PartitionPrinciple /Models /GroundQuotientBinaryOperations.lean
| 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 | |