openAI-math-dataset / lean /OAI /Combinatorics /BalancedRyser /Local /LocalConfigurationPattern.lean
| import OAI.Combinatorics.BalancedRyser.Incidence.AffineIncidence | |
| import OAI.Combinatorics.BalancedRyser.Local.Local | |
| import OAI.Combinatorics.BalancedRyser.Probability.ConfigurationStructure | |
| namespace OAI | |
| namespace Balanced.Local.ConfigurationPattern | |
| noncomputable section | |
| attribute [local instance] Classical.propDecidable | |
| variable {F : Type*} [Field F] [Fintype F] [DecidableEq F] | |
| variable (C : Configuration F) (hV : C.Valid) (hC : C.Compatible) (p : Point F) | |
| def slots : Finset (Slot F) := | |
| Finset.univ.filter (fun s => OnLine p (C.choice s).line) | |
| def slotEquiv : Fin (C.splitMultiplicity p) ≃ {s // s ∈ slots C p} := | |
| (Fintype.equivFinOfCardEq (by | |
| rw [Fintype.card_coe] | |
| exact (ConfigurationStructure.split_multiplicity_eq_slots C hV hC p).symm)).symm | |
| def slot (i : Fin (C.splitMultiplicity p)) : Slot F := | |
| (slotEquiv C hV hC p i).val | |
| theorem slot_injective : Function.Injective (slot C hV hC p) := | |
| Subtype.val_injective.comp (slotEquiv C hV hC p).injective | |
| theorem slot_onLine (i : Fin (C.splitMultiplicity p)) : | |
| OnLine p (C.choice (slot C hV hC p i)).line := | |
| (Finset.mem_filter.mp (slotEquiv C hV hC p i).property).2 | |
| theorem exists_slot {s : Slot F} (hs : OnLine p (C.choice s).line) : | |
| ∃ i, slot C hV hC p i = s := by | |
| let t : {s // s ∈ slots C p} := ⟨s, Finset.mem_filter.mpr ⟨Finset.mem_univ _, hs⟩⟩ | |
| refine ⟨(slotEquiv C hV hC p).symm t, ?_⟩ | |
| exact congrArg Subtype.val ((slotEquiv C hV hC p).apply_symm_apply t) | |
| theorem slot_direction_injective : | |
| Function.Injective (fun i => (slot C hV hC p i).1) := by | |
| intro i j hij | |
| apply slot_injective C hV hC p | |
| apply ConfigurationStructure.choice_line_injective C hV hC | |
| apply eq_of_onLine_same_direction p | |
| · exact (hV.2 _).1.trans (hij.trans (hV.2 _).1.symm) | |
| · exact slot_onLine C hV hC p i | |
| · exact slot_onLine C hV hC p j | |
| theorem slot_line_eq (i : Fin (C.splitMultiplicity p)) : | |
| (C.choice (slot C hV hC p i)).line = | |
| lineThrough (slot C hV hC p i).1 p := by | |
| apply eq_of_onLine_same_direction p | |
| · exact (hV.2 _).1 | |
| · exact slot_onLine C hV hC p i | |
| · exact onLine_lineThrough _ _ | |
| def point (ij : Fin (C.splitMultiplicity p) × Fin 4) : Point F := | |
| tuplePoint C.merged (C.choice (slot C hV hC p ij.1)).tuple ij.2 | |
| theorem point_injective : Function.Injective (point C hV hC p) := by | |
| rintro ⟨i, a⟩ ⟨j, b⟩ he | |
| have hi : slot C hV hC p i = slot C hV hC p j := by | |
| apply ConfigurationStructure.designated_slot_unique C hC | |
| (p := point C hV hC p (i, a)) | |
| · exact Finset.mem_image.mpr ⟨a, Finset.mem_univ _, rfl⟩ | |
| · rw [he] | |
| exact (hV.2 _).2.2.2.2.2.1 b | |
| have hij := slot_injective C hV hC p hi | |
| subst j | |
| have hab : a = b := (hV.2 _).2.2.2.2.1 he | |
| exact Prod.ext rfl hab | |
| theorem point_ne_center (hb : 2 ≤ C.splitMultiplicity p) | |
| (ij : Fin (C.splitMultiplicity p) × Fin 4) : point C hV hC p ij ≠ p := by | |
| intro he | |
| apply ConfigurationStructure.center_not_designated C hC hb (slot C hV hC p ij.1) | |
| have hx : point C hV hC p ij ∈ | |
| designated C.merged (C.choice (slot C hV hC p ij.1)) := | |
| Finset.mem_image.mpr ⟨ij.2, Finset.mem_univ _, rfl⟩ | |
| simpa only [he] using hx | |
| theorem point_image : Finset.univ.image (point C hV hC p) = C.designatedAt p := by | |
| ext x | |
| constructor | |
| · rintro hx | |
| obtain ⟨⟨i, a⟩, _, rfl⟩ := Finset.mem_image.mp hx | |
| exact Finset.mem_biUnion.mpr ⟨slot C hV hC p i, | |
| Finset.mem_filter.mpr ⟨Finset.mem_univ _, slot_onLine C hV hC p i⟩, | |
| Finset.mem_image.mpr ⟨a, Finset.mem_univ _, rfl⟩⟩ | |
| · intro hx | |
| obtain ⟨s, hs, hx⟩ := Finset.mem_biUnion.mp hx | |
| obtain ⟨i, rfl⟩ := exists_slot C hV hC p (Finset.mem_filter.mp hs).2 | |
| obtain ⟨a, _, rfl⟩ := Finset.mem_image.mp hx | |
| exact Finset.mem_image.mpr ⟨(i, a), Finset.mem_univ _, rfl⟩ | |
| def generator (ij : Fin (C.splitMultiplicity p) × Fin 4) : Direction F := | |
| (C.choice (slot C hV hC p ij.1)).tuple.generator ij.2 | |
| theorem generator_image : | |
| Finset.univ.image (generator C hV hC p) = generatorUnionAt C p := by | |
| ext d | |
| constructor | |
| · intro hd | |
| obtain ⟨⟨i, j⟩, _, rfl⟩ := Finset.mem_image.mp hd | |
| exact Finset.mem_biUnion.mpr ⟨slot C hV hC p i, | |
| Finset.mem_filter.mpr ⟨Finset.mem_univ _, slot_onLine C hV hC p i⟩, | |
| Finset.mem_image.mpr ⟨j, Finset.mem_univ _, rfl⟩⟩ | |
| · intro hd | |
| obtain ⟨s, hs, hd⟩ := Finset.mem_biUnion.mp hd | |
| obtain ⟨i, rfl⟩ := exists_slot C hV hC p (Finset.mem_filter.mp hs).2 | |
| obtain ⟨j, _, rfl⟩ := Finset.mem_image.mp hd | |
| exact Finset.mem_image.mpr ⟨(i, j), Finset.mem_univ _, rfl⟩ | |
| include hV hC | |
| theorem generator_card_le : | |
| (generatorUnionAt C p).card ≤ 4 * C.splitMultiplicity p := by | |
| rw [← generator_image C hV hC p] | |
| simpa [Nat.mul_comm] using | |
| (Finset.card_image_le (s := Finset.univ) (f := generator C hV hC p)) | |
| theorem generator_card_eq : | |
| (generatorUnionAt C p).card = 4 * C.splitMultiplicity p - reuseCount C p := by | |
| exact (Nat.sub_sub_self (generator_card_le C hV hC p)).symm | |
| def generatorEquiv : {d // d ∈ generatorUnionAt C p} ≃ | |
| Fin (4 * C.splitMultiplicity p - reuseCount C p) := | |
| Fintype.equivFinOfCardEq (by | |
| rw [Fintype.card_coe] | |
| exact generator_card_eq C hV hC p) | |
| theorem generator_mem (ij : Fin (C.splitMultiplicity p) × Fin 4) : | |
| generator C hV hC p ij ∈ generatorUnionAt C p := by | |
| rw [← generator_image C hV hC p] | |
| exact Finset.mem_image.mpr ⟨ij, Finset.mem_univ _, rfl⟩ | |
| def classOf (i : Fin (C.splitMultiplicity p)) (j : Fin 4) : | |
| Fin (4 * C.splitMultiplicity p - reuseCount C p) := | |
| generatorEquiv C hV hC p ⟨generator C hV hC p (i, j), generator_mem C hV hC p (i, j)⟩ | |
| def assignedGenerator (k : Fin (4 * C.splitMultiplicity p - reuseCount C p)) : | |
| Direction F := ((generatorEquiv C hV hC p).symm k).val | |
| theorem assignedGenerator_injective : Function.Injective (assignedGenerator C hV hC p) := | |
| Subtype.val_injective.comp (generatorEquiv C hV hC p).symm.injective | |
| theorem assigned_class (i : Fin (C.splitMultiplicity p)) (j : Fin 4) : | |
| assignedGenerator C hV hC p (classOf C hV hC p i j) = | |
| (C.choice (slot C hV hC p i)).tuple.generator j := by | |
| exact congrArg Subtype.val ((generatorEquiv C hV hC p).symm_apply_apply _) | |
| theorem class_surjective : | |
| Function.Surjective (fun ij : Fin (C.splitMultiplicity p) × Fin 4 => | |
| classOf C hV hC p ij.1 ij.2) := by | |
| intro k | |
| have hd := ((generatorEquiv C hV hC p).symm k).property | |
| have hd' : assignedGenerator C hV hC p k ∈ Finset.univ.image (generator C hV hC p) := by | |
| rw [generator_image] | |
| exact hd | |
| obtain ⟨⟨i, j⟩, _, he⟩ := Finset.mem_image.mp hd' | |
| refine ⟨(i, j), ?_⟩ | |
| apply assignedGenerator_injective C hV hC p | |
| exact (assigned_class C hV hC p i j).trans he | |
| theorem class_injective (i : Fin (C.splitMultiplicity p)) : | |
| Function.Injective (classOf C hV hC p i) := by | |
| intro j k h | |
| apply (hV.2 (slot C hV hC p i)).2.2.1 | |
| simpa only [assigned_class] using congrArg (assignedGenerator C hV hC p) h | |
| theorem assigned_mem_generators {i : Fin (C.splitMultiplicity p)} | |
| {k : Fin (4 * C.splitMultiplicity p - reuseCount C p)} | |
| (hk : k ∈ Finset.univ.image (classOf C hV hC p i)) : | |
| assignedGenerator C hV hC p k ∈ generatorSet (C.choice (slot C hV hC p i)).tuple := by | |
| obtain ⟨j, _, rfl⟩ := Finset.mem_image.mp hk | |
| rw [assigned_class] | |
| exact Finset.mem_image.mpr ⟨j, Finset.mem_univ _, rfl⟩ | |
| theorem class_pair_overlap (i j : Fin (C.splitMultiplicity p)) (hne : i ≠ j) : | |
| ((Finset.univ.image (classOf C hV hC p i)) ∩ | |
| (Finset.univ.image (classOf C hV hC p j))).card ≤ 1 := by | |
| apply Finset.card_le_one.mpr | |
| intro x hx y hy | |
| apply assignedGenerator_injective C hV hC p | |
| have hc := hC.2.1 (slot C hV hC p i) (slot C hV hC p j) | |
| (fun he => hne (slot_injective C hV hC p he)) | |
| apply Finset.card_le_one.mp hc | |
| · exact Finset.mem_inter.mpr ⟨assigned_mem_generators C hV hC p (Finset.mem_inter.mp hx).1, | |
| assigned_mem_generators C hV hC p (Finset.mem_inter.mp hx).2⟩ | |
| · exact Finset.mem_inter.mpr ⟨assigned_mem_generators C hV hC p (Finset.mem_inter.mp hy).1, | |
| assigned_mem_generators C hV hC p (Finset.mem_inter.mp hy).2⟩ | |
| def pattern : EqualityPattern (C.splitMultiplicity p) (reuseCount C p) where | |
| classOf := classOf C hV hC p | |
| everyClass := class_surjective C hV hC p | |
| withinTuple := class_injective C hV hC p | |
| pairOverlap := class_pair_overlap C hV hC p | |
| def assignment : DirectionAssignment F (C.splitMultiplicity p) (reuseCount C p) := | |
| (fun i => (slot C hV hC p i).1, assignedGenerator C hV hC p) | |
| def bits : Bits (C.splitMultiplicity p) := | |
| fun i => (C.choice (slot C hV hC p i)).tuple.side | |
| theorem assignment_eligible : Eligible (pattern C hV hC p) (assignment C hV hC p) := by | |
| refine ⟨slot_direction_injective C hV hC p, assignedGenerator_injective C hV hC p, ?_⟩ | |
| intro i j | |
| change assignedGenerator C hV hC p (classOf C hV hC p i j) ≠ (slot C hV hC p i).1 | |
| rw [assigned_class] | |
| exact (hV.2 _).2.2.2.1 j | |
| theorem prescribedTuple_eq (i : Fin (C.splitMultiplicity p)) : | |
| prescribedTuple (pattern C hV hC p) (assignment C hV hC p) (bits C hV hC p) i = | |
| (C.choice (slot C hV hC p i)).tuple := by | |
| apply (show ∀ s t : FourTuple F, s.generator = t.generator → s.side = t.side → s = t from by | |
| intro s t hg hs | |
| cases s | |
| cases t | |
| cases hg | |
| cases hs | |
| rfl) | |
| · funext j | |
| exact assigned_class C hV hC p i j | |
| · rfl | |
| theorem prescribedPoint_eq (ij : Fin (C.splitMultiplicity p) × Fin 4) : | |
| prescribedPoint (pattern C hV hC p) (assignment C hV hC p) (bits C hV hC p) C.merged ij = | |
| point C hV hC p ij := by | |
| unfold prescribedPoint | |
| rw [prescribedTuple_eq] | |
| rfl | |
| theorem aligned : | |
| Aligned (pattern C hV hC p) (assignment C hV hC p) (bits C hV hC p) p C.merged := by | |
| intro ij | |
| rw [prescribedPoint_eq] | |
| change OnLine (point C hV hC p ij) (lineThrough (slot C hV hC p ij.1).1 p) | |
| rw [← slot_line_eq C hV hC p ij.1] | |
| exact (hV.2 _).2.2.2.2.2.1 ij.2 | |
| theorem admissible (hb : 2 ≤ C.splitMultiplicity p) | |
| (hcap : ∀ x, constituentMultiplicity C.merged x ≤ logBudget F) : | |
| Admissible (pattern C hV hC p) (assignment C hV hC p) (bits C hV hC p) p C.merged := by | |
| refine ⟨aligned C hV hC p, ?_, ?_, ?_, hcap⟩ | |
| · intro ij kl h | |
| apply point_injective C hV hC p | |
| simpa only [prescribedPoint_eq] using h | |
| · intro ij | |
| rw [prescribedPoint_eq] | |
| exact point_ne_center C hV hC p hb ij | |
| · intro i | |
| change lineThrough (slot C hV hC p i).1 p ∉ constituentLines C.merged | |
| rw [← slot_line_eq C hV hC p i] | |
| exact (hV.2 _).2.1 | |
| theorem prescribedDesignated_eq : | |
| prescribedDesignated (pattern C hV hC p) (assignment C hV hC p) | |
| (bits C hV hC p) C.merged = C.designatedAt p := by | |
| have he : prescribedPoint (pattern C hV hC p) (assignment C hV hC p) | |
| (bits C hV hC p) C.merged = point C hV hC p := | |
| funext (prescribedPoint_eq C hV hC p) | |
| unfold prescribedDesignated | |
| rw [he] | |
| exact point_image C hV hC p | |
| theorem prescribedPartners_eq : | |
| prescribedPartners (pattern C hV hC p) (assignment C hV hC p) | |
| (bits C hV hC p) p C.merged = C.partnerSet p := by | |
| unfold prescribedPartners Configuration.partnerSet | |
| rw [prescribedDesignated_eq] | |
| theorem target_line_image : | |
| (Finset.univ.image (fun i => lineThrough ((assignment C hV hC p).1 i) p)) = | |
| C.splitLinesAt p := by | |
| ext l | |
| constructor | |
| · intro hl | |
| obtain ⟨i, _, rfl⟩ := Finset.mem_image.mp hl | |
| change lineThrough (slot C hV hC p i).1 p ∈ C.splitLinesAt p | |
| rw [← slot_line_eq C hV hC p i] | |
| exact Finset.mem_filter.mpr ⟨ConfigurationStructure.choice_line_mem_split C _, | |
| slot_onLine C hV hC p i⟩ | |
| · intro hl | |
| obtain ⟨hl, hp⟩ := Finset.mem_filter.mp hl | |
| obtain ⟨s, _, rfl⟩ := Finset.mem_image.mp hl | |
| obtain ⟨i, rfl⟩ := exists_slot C hV hC p hp | |
| exact Finset.mem_image.mpr ⟨i, Finset.mem_univ _, (slot_line_eq C hV hC p i).symm⟩ | |
| theorem allowedPiece_iff (A : LocalPiece F) : | |
| AllowedPiece (assignment C hV hC p) p C.merged A ↔ C.AllowedLocalPiece p A := by | |
| rcases A with U | l | d | |
| · rfl | |
| · change l ∉ (Finset.univ.image (fun i => lineThrough ((assignment C hV hC p).1 i) p)) ∪ | |
| constituentLines C.merged ↔ l ∉ C.splitLinesAt p ∪ constituentLines C.merged | |
| rw [target_line_image] | |
| · rfl | |
| theorem badCover_iff : | |
| BadCover (pattern C hV hC p) (assignment C hV hC p) (bits C hV hC p) p C.merged ↔ | |
| ∃ A : Finset (LocalPiece F), A.card ≤ C.splitMultiplicity p - 1 ∧ | |
| (∀ a ∈ A, C.AllowedLocalPiece p a) ∧ | |
| C.designatedAt p ⊆ C.partnerSet p ∪ A.biUnion C.localPiecePoints := by | |
| unfold BadCover | |
| rw [prescribedDesignated_eq, prescribedPartners_eq] | |
| simp only [allowedPiece_iff] | |
| rfl | |
| theorem exists_pattern_of_not_local | |
| (hcap : ∀ x, constituentMultiplicity C.merged x ≤ logBudget F) | |
| (hbad : ¬ C.LocalCondition) : | |
| ∃ p : Point F, 3 ≤ C.splitMultiplicity p ∧ | |
| ∃ (P : EqualityPattern (C.splitMultiplicity p) (reuseCount C p)) | |
| (a : DirectionAssignment F (C.splitMultiplicity p) (reuseCount C p)) | |
| (side : Bits (C.splitMultiplicity p)), | |
| Eligible P a ∧ AdmissibleBadCover P a side p C.merged := by | |
| unfold Configuration.LocalCondition at hbad | |
| push Not at hbad | |
| obtain ⟨p, hb, hA⟩ := hbad | |
| exact ⟨p, hb, pattern C hV hC p, assignment C hV hC p, bits C hV hC p, | |
| assignment_eligible C hV hC p, | |
| admissible C hV hC p (by omega) hcap, (badCover_iff C hV hC p).mpr hA⟩ | |
| end | |
| end Balanced.Local.ConfigurationPattern | |
| end OAI | |