openAI-math-dataset / lean /OAI /SetTheory /PartitionPrinciple /Models /GroundQuotientUnaryOperations.lean
| import OAI.SetTheory.PartitionPrinciple.Definability.GroundFlatCopyGraphs | |
| namespace OAI | |
| section | |
| namespace PartitionPilot.Forcing | |
| open SetRealization | |
| universe u | |
| def quotientUnaryGraph (W Q classifier op : ZFSet.{u}) : ZFSet.{u} := | |
| ZFSet.sep (fun z => ∃ a ∈ Q, ∃ b ∈ Q, z = ZFSet.pair a b ∧ | |
| ∃ x ∈ W, ∃ y ∈ W, ZFSet.pair x a ∈ classifier ∧ | |
| ZFSet.pair y b ∈ classifier ∧ ZFSet.pair x y ∈ op) (ZFSet.prod Q Q) | |
| theorem mem_quotientUnaryGraph (W Q classifier op z : ZFSet.{u}) : | |
| z ∈ quotientUnaryGraph W Q classifier op ↔ | |
| ∃ a ∈ Q, ∃ b ∈ Q, z = ZFSet.pair a b ∧ ∃ x ∈ W, ∃ y ∈ W, | |
| ZFSet.pair x a ∈ classifier ∧ ZFSet.pair y b ∈ classifier ∧ ZFSet.pair x y ∈ op := by | |
| rw [quotientUnaryGraph, ZFSet.mem_sep] | |
| refine ⟨And.right, ?_⟩ | |
| rintro ⟨a, ha, b, hb, eq, rest⟩ | |
| exact ⟨eq.symm ▸ ZFSet.pair_mem_prod.2 ⟨ha, hb⟩, a, ha, b, hb, eq, rest⟩ | |
| theorem pair_mem_quotientUnaryGraph (W Q classifier op a b : ZFSet.{u}) : | |
| ZFSet.pair a b ∈ quotientUnaryGraph W Q classifier op ↔ | |
| a ∈ Q ∧ b ∈ Q ∧ ∃ x ∈ W, ∃ y ∈ W, | |
| ZFSet.pair x a ∈ classifier ∧ ZFSet.pair y b ∈ classifier ∧ ZFSet.pair x y ∈ op := by | |
| rw [mem_quotientUnaryGraph] | |
| constructor | |
| · rintro ⟨a', ha, b', hb, eq, rest⟩ | |
| obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 eq | |
| exact ⟨ha, hb, rest⟩ | |
| · rintro ⟨ha, hb, rest⟩ | |
| exact ⟨a, ha, b, hb, rfl, rest⟩ | |
| theorem quotientUnaryGraph_eq_graph {A B : Type u} (s : Presentation A) (t : Presentation B) | |
| (q : A → B) (source : A → A) (target : B → B) | |
| (onto : Function.Surjective q) (compatible : ∀ x, q (source x) = target (q x)) : | |
| quotientUnaryGraph s.carrier t.carrier (s.graph t q) (s.graph s source) = t.graph t target := by | |
| apply ZFSet.ext | |
| intro z | |
| rw [mem_quotientUnaryGraph, Presentation.mem_graph] | |
| constructor | |
| · rintro ⟨a, ha, b, hb, rfl, x, hx, y, hy, xa, yb, op⟩ | |
| obtain ⟨a, rfl⟩ := (t.mem_carrier a).1 ha | |
| obtain ⟨b, rfl⟩ := (t.mem_carrier b).1 hb | |
| obtain ⟨x, rfl⟩ := (s.mem_carrier x).1 hx | |
| obtain ⟨y, rfl⟩ := (s.mem_carrier y).1 hy | |
| have first := (s.pair_mem_graph t q x a).1 xa | |
| have output := (s.pair_mem_graph t q y b).1 yb | |
| have value := (s.pair_mem_graph s source x y).1 op | |
| have equal : target a = b := by | |
| rw [← first, ← compatible, value] | |
| exact output | |
| exact ⟨a, by rw [equal]⟩ | |
| · rintro ⟨a, rfl⟩ | |
| obtain ⟨x, rfl⟩ := onto a | |
| exact ⟨t.encode (q x), t.encode_mem _, t.encode (target (q x)), t.encode_mem _, rfl, | |
| s.encode x, s.encode_mem _, s.encode (source x), s.encode_mem _, | |
| (s.pair_mem_graph t q _ _).2 rfl, (s.pair_mem_graph t q _ _).2 (compatible x), | |
| (s.pair_mem_graph s source _ _).2 rfl⟩ | |
| theorem quotientUnaryGraph_function {A B : Type u} (s : Presentation A) (t : Presentation B) | |
| (q : A → B) (source : A → A) (target : B → B) | |
| (onto : Function.Surjective q) (compatible : ∀ x, q (source x) = target (q x)) : | |
| ZFSet.IsFunc t.carrier t.carrier | |
| (quotientUnaryGraph s.carrier t.carrier (s.graph t q) (s.graph s source)) := by | |
| rw [quotientUnaryGraph_eq_graph s t q source target onto compatible] | |
| exact t.graph_isFunc t target | |
| end PartitionPilot.Forcing | |
| namespace PartitionPilot.Forcing | |
| open SetFormula | |
| universe u | |
| namespace BoundedFormula | |
| def quotientUnaryEntryFormula {n} (z w q classifier op : Fin n) : BoundedFormula n := | |
| exMem q (exMem q.succ (.conj (orderedPairFormula z.succ.succ 1 0) | |
| (exMem w.succ.succ (exMem w.succ.succ.succ | |
| (.conj (pairMembershipFormula 1 3 classifier.succ.succ.succ.succ) | |
| (.conj (pairMembershipFormula 0 2 classifier.succ.succ.succ.succ) | |
| (pairMembershipFormula 1 0 op.succ.succ.succ.succ))))))) | |
| theorem truth_quotientUnaryEntryFormula {n} (z w q classifier op : Fin n) | |
| (env : Fin n → ZFSet.{u}) : | |
| Truth (quotientUnaryEntryFormula z w q classifier op) env ↔ | |
| env z ∈ quotientUnaryGraph (env w) (env q) (env classifier) (env op) := by | |
| simp only [quotientUnaryEntryFormula, truth_exMem, Truth, truth_orderedPairFormula, | |
| truth_pairMembershipFormula, mem_quotientUnaryGraph] | |
| rfl | |
| end BoundedFormula | |
| namespace TransitiveGround | |
| theorem quotientUnaryGraph_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) : | |
| quotientUnaryGraph W Q classifier op ∈ M.sets := by | |
| have bound := M.prod_mem pairing unions powers separation hQ hQ | |
| let params := extend W (extend Q (extend classifier (extend op Fin.elim0))) | |
| have selected := M.bounded_separation_mem separation | |
| (BoundedFormula.quotientUnaryEntryFormula 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.quotientUnaryEntryFormula 0 1 2 3 4) (extend z params)) | |
| (ZFSet.prod Q Q) = quotientUnaryGraph W Q classifier op := by | |
| apply ZFSet.ext | |
| intro z | |
| rw [ZFSet.mem_sep, BoundedFormula.truth_quotientUnaryEntryFormula] | |
| change (z ∈ ZFSet.prod Q Q ∧ z ∈ quotientUnaryGraph 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 | |