import OAI.Algorithms.SubexponentialSAT.LeanCompat import OAI.Algorithms.SubexponentialSAT.BlockPacking namespace OAI.Algorithms /-! # Coordinate embeddings and packed direct sums Extension by zero realizes copies of a local subspace on pairwise disjoint blocks. The actual embedding is injective, so its range has the sum of the local dimensions. No runtime claim is made for these algebraic constructions. -/ namespace SubexponentialSAT.DirectSums open Module open scoped BigOperators section Extension variable {R α β : Type*} [Semiring R] /-- Extend a coordinate vector by zero along an injective coordinate map. -/ noncomputable def extendLinear (e : β ↪ α) : (β → R) →ₗ[R] (α → R) where toFun v := Function.extend e v 0 map_add' v w := by funext a by_cases h : a ∈ Set.range e · obtain ⟨b, rfl⟩ := h simp only [e.injective.extend_apply, Pi.add_apply] · simp only [Set.mem_range] at h simp only [Function.extend_apply' _ _ _ h, Pi.add_apply, Pi.zero_apply, zero_add] map_smul' c v := by funext a by_cases h : a ∈ Set.range e · obtain ⟨b, rfl⟩ := h simp only [e.injective.extend_apply, Pi.smul_apply, RingHom.id_apply] · simp only [Set.mem_range] at h simp only [Function.extend_apply' _ _ _ h, Pi.smul_apply, Pi.zero_apply, smul_zero, RingHom.id_apply] @[simp] theorem extendLinear_apply (e : β ↪ α) (v : β → R) (b : β) : extendLinear e v (e b) = v b := e.injective.extend_apply _ _ _ theorem extendLinear_zero_outside (e : β ↪ α) (v : β → R) (a : α) (ha : a ∉ Set.range e) : extendLinear e v a = 0 := Function.extend_apply' _ _ _ ha theorem extendLinear_injective (e : β ↪ α) : Function.Injective (extendLinear (R := R) e) := by intro v w h funext b simpa only [extendLinear_apply] using congrFun h (e b) /-- In particular, a coordinate embedding preserves the dimension of every local subspace; extra ambient coordinates are identically zero. -/ theorem finrank_map_extendLinear {K : Type*} [Field K] [Fintype β] (e : β ↪ α) (V : Submodule K (β → K)) : finrank K (V.map (extendLinear e)) = finrank K V := (Submodule.equivMapOfInjective (extendLinear e) (extendLinear_injective e) V).finrank_eq.symm /-- Extending the row and pairing with an arbitrary ambient vector is the same as first restricting the vector to the embedded coordinates. -/ theorem sum_extendLinear_mul [Fintype α] [Fintype β] (e : β ↪ α) (row : β → R) (v : α → R) : (∑ a, extendLinear e row a * v a) = ∑ b, row b * v (e b) := by classical calc (∑ a, extendLinear e row a * v a) = ∑ a ∈ Finset.univ.map e, extendLinear e row a * v a := by symm apply Finset.sum_subset (Finset.subset_univ _) intro a _ ha have hout : a ∉ Set.range e := by rintro ⟨b, rfl⟩ exact ha (Finset.mem_map.mpr ⟨b, Finset.mem_univ _, rfl⟩) rw [extendLinear_zero_outside e row a hout, zero_mul] _ = ∑ b, row b * v (e b) := by simp /-- The pairing identity allows the local vector and the row to be over different fields, through the supplied coefficient homomorphism. -/ theorem sum_extendLinear_mul_hom {K : Type*} [Semiring K] [Fintype α] [Fintype β] (e : β ↪ α) (φ : K →+* R) (row : β → R) (v : α → K) : (∑ a, extendLinear e row a * φ (v a)) = ∑ b, row b * φ (v (e b)) := sum_extendLinear_mul e row (fun a => φ (v a)) end Extension section Packed variable {K α τ I : Type*} [Field K] /-- Forget each local subspace proof and uncurry the block coordinates. -/ def blockCoordinates (V : Submodule K (τ → K)) : (I → V) →ₗ[K] (I × τ → K) where toFun v z := (v z.1).val z.2 map_add' _ _ := rfl map_smul' _ _ := rfl /-- Place one vector from the local subspace into each disjoint block. -/ noncomputable def packedLinear (e : I × τ ↪ α) (V : Submodule K (τ → K)) : (I → V) →ₗ[K] (α → K) := (extendLinear e).comp (blockCoordinates V) @[simp] theorem packedLinear_apply (e : I × τ ↪ α) (V : Submodule K (τ → K)) (v : I → V) (i : I) (u : τ) : packedLinear e V v (e (i, u)) = (v i).val u := extendLinear_apply e _ _ theorem packedLinear_zero_outside (e : I × τ ↪ α) (V : Submodule K (τ → K)) (v : I → V) (a : α) (ha : a ∉ Set.range e) : packedLinear e V v a = 0 := extendLinear_zero_outside e _ a ha theorem packedLinear_injective (e : I × τ ↪ α) (V : Submodule K (τ → K)) : Function.Injective (packedLinear e V) := by intro v w h funext i apply Subtype.ext funext u simpa only [packedLinear_apply] using congrFun h (e (i, u)) /-- The actual ambient direct sum, represented as a subspace of all coordinates. -/ noncomputable def packedSubspace (e : I × τ ↪ α) (V : Submodule K (τ → K)) : Submodule K (α → K) := LinearMap.range (packedLinear e V) theorem mem_packedSubspace_iff (e : I × τ ↪ α) (V : Submodule K (τ → K)) (r : α → K) : r ∈ packedSubspace e V ↔ (∀ i, (fun u => r (e (i, u))) ∈ V) ∧ (∀ a, a ∉ Set.range e → r a = 0) := by constructor · rintro ⟨v, rfl⟩ constructor · intro i simpa only [packedLinear_apply] using (v i).property · exact packedLinear_zero_outside e V v · rintro ⟨hlocal, hout⟩ refine ⟨fun i => ⟨fun u => r (e (i, u)), hlocal i⟩, ?_⟩ funext a by_cases ha : a ∈ Set.range e · obtain ⟨⟨i, u⟩, rfl⟩ := ha exact packedLinear_apply e V _ i u · rw [packedLinear_zero_outside e V _ a ha, hout a ha] theorem packed_restriction_mem (e : I × τ ↪ α) (V : Submodule K (τ → K)) {r : α → K} (hr : r ∈ packedSubspace e V) (i : I) : (fun u => r (e (i, u))) ∈ V := ((mem_packedSubspace_iff e V r).mp hr).1 i theorem packed_zero_outside (e : I × τ ↪ α) (V : Submodule K (τ → K)) {r : α → K} (hr : r ∈ packedSubspace e V) (a : α) (ha : a ∉ Set.range e) : r a = 0 := ((mem_packedSubspace_iff e V r).mp hr).2 a ha /-- The coordinate embedding of one block inside a packed family. -/ def blockEmbedding (e : I × τ ↪ α) (i : I) : τ ↪ α where toFun u := e (i, u) inj' _ _ h := congrArg Prod.snd (e.injective h) /-- A local annihilating row remains annihilating after extension into any one block. Coefficients may be in a larger ring than the vector space. -/ theorem packed_annihilation {E : Type*} [Semiring E] [Fintype α] [Fintype τ] (e : I × τ ↪ α) (V : Submodule K (τ → K)) (i : I) (φ : K →+* E) (row : τ → E) (hrow : ∀ v ∈ V, (∑ u, row u * φ (v u)) = 0) {r : α → K} (hr : r ∈ packedSubspace e V) : (∑ a, extendLinear (blockEmbedding e i) row a * φ (r a)) = 0 := by rw [sum_extendLinear_mul_hom] exact hrow _ (packed_restriction_mem e V hr i) /-- Explicit linear equivalence with the finite product of local spaces. -/ noncomputable def packedEquiv (e : I × τ ↪ α) (V : Submodule K (τ → K)) : (I → V) ≃ₗ[K] packedSubspace e V := LinearEquiv.ofInjective (packedLinear e V) (packedLinear_injective e V) theorem finrank_packedSubspace [Fintype I] [Fintype τ] (e : I × τ ↪ α) (V : Submodule K (τ → K)) : finrank K (packedSubspace e V) = Fintype.card I * finrank K V := by rw [← (packedEquiv e V).finrank_eq, Module.finrank_pi_fintype] simp /-- Transport of a local coordinate support into all packed blocks. -/ def packedSupport (e : I × τ ↪ α) (S : Set τ) : Set α := {a | ∃ i u, u ∈ S ∧ e (i, u) = a} theorem packedSupport_disjoint (e : I × τ ↪ α) (S0 S1 : Set τ) (h : Disjoint S0 S1) : Disjoint (packedSupport e S0) (packedSupport e S1) := by apply Set.disjoint_left.mpr rintro a ⟨i, u, hu, ha⟩ ⟨j, v, hv, hb⟩ have huv : u = v := congrArg Prod.snd (e.injective (ha.trans hb.symm)) exact Set.disjoint_left.mp h hu (huv ▸ hv) theorem packed_supported (e : I × τ ↪ α) (V : Submodule K (τ → K)) (S : Set τ) (hV : ∀ v ∈ V, ∀ u, u ∉ S → v u = 0) {r : α → K} (hr : r ∈ packedSubspace e V) (a : α) (ha : a ∉ packedSupport e S) : r a = 0 := by by_cases he : a ∈ Set.range e · obtain ⟨⟨i, u⟩, rfl⟩ := he have hu : u ∉ S := fun h => ha ⟨i, u, h, rfl⟩ exact hV _ (packed_restriction_mem e V hr i) u hu · exact packed_zero_outside e V hr a he /-- Finite-set form of the transported support used by the layout interface. -/ def packedSupportFinset [Fintype I] (e : I × τ ↪ α) (S : Finset τ) : Finset α := (Finset.univ.product S).map e @[simp] theorem mem_packedSupportFinset [Fintype I] (e : I × τ ↪ α) (S : Finset τ) (a : α) : a ∈ packedSupportFinset e S ↔ ∃ i u, u ∈ S ∧ e (i, u) = a := by classical simp [packedSupportFinset, Finset.mem_map, Prod.exists] @[simp] theorem embedded_mem_packedSupportFinset [Fintype I] (e : I × τ ↪ α) (S : Finset τ) (i : I) (u : τ) : e (i, u) ∈ packedSupportFinset e S ↔ u ∈ S := by rw [mem_packedSupportFinset] constructor · rintro ⟨j, v, hv, h⟩ have hvu : v = u := congrArg Prod.snd (e.injective h) exact hvu ▸ hv · intro hu exact ⟨i, u, hu, rfl⟩ theorem packedSupportFinset_disjoint [Fintype I] (e : I × τ ↪ α) (S0 S1 : Finset τ) (h : Disjoint S0 S1) : Disjoint (packedSupportFinset e S0) (packedSupportFinset e S1) := by classical apply Finset.disjoint_left.mpr intro a ha hb obtain ⟨i, u, hu, ha⟩ := (mem_packedSupportFinset e S0 a).mp ha obtain ⟨j, v, hv, hb⟩ := (mem_packedSupportFinset e S1 a).mp hb have huv : u = v := congrArg Prod.snd (e.injective (ha.trans hb.symm)) exact Finset.disjoint_left.mp h hu (huv ▸ hv) theorem packed_supported_finset [Fintype I] (e : I × τ ↪ α) (V : Submodule K (τ → K)) (S : Finset τ) (hV : ∀ v ∈ V, ∀ u, u ∉ S → v u = 0) {r : α → K} (hr : r ∈ packedSubspace e V) (a : α) (ha : a ∉ packedSupportFinset e S) : r a = 0 := by apply packed_supported e V (↑S) hV hr a intro h exact ha ((mem_packedSupportFinset e S a).mpr h) /-- The manuscript's full-block proportion and three-quarter coverage imply the required quarter-dimensional ambient subspace. -/ theorem packed_quarter_dimension [Fintype I] [Fintype τ] [Fintype α] (e : I × τ ↪ α) (V : Submodule K (τ → K)) (hlocal : 7 * Fintype.card τ ≤ 16 * finrank K V) (hcover : 3 * Fintype.card α ≤ 4 * (Fintype.card I * Fintype.card τ)) : Fintype.card α ≤ 4 * finrank K (packedSubspace e V) := by rw [finrank_packedSubspace] have hm := Nat.mul_le_mul_left (Fintype.card I) hlocal nlinarith /-- The quantitative bound before weakening it to a quarter. -/ theorem packed_twentyone_sixtyfour_dimension [Fintype I] [Fintype τ] [Fintype α] (e : I × τ ↪ α) (V : Submodule K (τ → K)) (hlocal : 7 * Fintype.card τ ≤ 16 * finrank K V) (hcover : 3 * Fintype.card α ≤ 4 * (Fintype.card I * Fintype.card τ)) : 21 * Fintype.card α ≤ 64 * finrank K (packedSubspace e V) := by rw [finrank_packedSubspace] have hm := Nat.mul_le_mul_left (Fintype.card I) hlocal nlinarith /-- Direct specialization to the complete blocks constructed by BlockPacking. -/ theorem completeBlocks_quarter_dimension [Fintype τ] [Fintype α] {label : α → τ} {b : ℕ} (P : BlockPacking.CompleteBlocks label b) (V : Submodule K (τ → K)) (hlocal : 7 * Fintype.card τ ≤ 16 * finrank K V) (hcover : 3 * Fintype.card α ≤ 4 * P.covered.card) : Fintype.card α ≤ 4 * finrank K (packedSubspace P.embed V) := by apply packed_quarter_dimension P.embed V hlocal simpa only [BlockPacking.CompleteBlocks.card_covered, Fintype.card_fin] using hcover end Packed end SubexponentialSAT.DirectSums end OAI.Algorithms