Sync from openai/math@faee2cf485a8 (part 10)

lean/OAI/Combinatorics/HadwigerCounterexample/PrimalChannelDecomposition.lean

@@ -1,123 +1,123 @@
-import OAI.Combinatorics.HadwigerCounterexample.RealizationConditions
-
-namespace OAI
-
-/-! # Primal Channel Decomposition -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open scoped BigOperators
-open Matrix Submodule
-variable {I : Type} [Fintype I]
-
-/-- Onto projection in coordinates, killing a specified disjoint subspace. -/
-structure ProjData (S T : Space (Vec I)) (A : Mat I I) : Prop where
-  onto (x) : A *ᵥ x ∈ S
-  fixes x : x ∈ S → A *ᵥ x=x
-  kills x : x∈T → A *ᵥ x=0
-
-theorem proj_exists (S T : Space (Vec I)) (h : Disjoint S T) :
-    ∃ A, ProjData S T A := by
-  classical
-  obtain ⟨A,hA⟩ := mat_left_inv (inj_fromCols (pack_inj S) (pack_inj T)
-    (by rw [colSp_pack, colSp_pack]; exact h))
-  let B := A.toRows₁
-  let C := A.toRows₂
-  have he : fromRows B C * fromCols (pack S) (pack T)=1 := by
-    rw [show fromRows B C=A from Matrix.fromRows_toRows A,hA]
-  rw [Matrix.fromRows_mul_fromCols, ← Matrix.fromBlocks_one] at he
-  have hb : B*pack S=1 := congrArg Matrix.toBlocks₁₁ he
-  have hg : B*pack T=0 := congrArg Matrix.toBlocks₁₂ he
-  refine ⟨pack S*B,fun x => ?_,fun x hx => ?_,fun x hx => ?_⟩
-  · rw [←mulVec_mulVec]
-    exact (pack_mem_iff ..).mpr ⟨_,rfl⟩
-  · obtain ⟨x,rfl⟩ := (pack_mem_iff ..).mp hx
-    rw [←mulVec_mulVec, mulVec_mulVec _ B, hb,one_mulVec]
-  · obtain ⟨x,rfl⟩ := (pack_mem_iff ..).mp hx
-    rw [←mulVec_mulVec,mulVec_mulVec _ B,hg,zero_mulVec,mulVec_zero]
-
-theorem rank_maps {J : Type} [Fintype J] {A : Mat I J} (S : Space (Vec I))
-    (ha : ∀ x,A *ᵥ x∈ S) : A.rank ≤ dim S :=
-  Submodule.finrank_mono (show colSp A ≤ S by
-    rintro x ⟨x,rfl⟩; exact ha x)
-
-theorem evmat_addM {J : Type} [Fintype J] (A B : Mat I J) (x y) :
-    evmat (A+B) x y = evmat A x y+evmat B x y := by rw [←mpair_outer,mpair_add,
-      mpair_outer,mpair_outer]
-
-theorem evmat_subM {J : Type} [Fintype J] (A B : Mat I J) (x y) :
-    evmat (A-B) x y = evmat A x y-evmat B x y := by
-  rw [ZModModule.sub_eq_add, ZModModule.sub_eq_add, evmat_addM]
-
-variable {p : Shape} {n : ℕ}
-
-/-- aggregate primal (resp. channel) directions in a unit. -/
-def primal (p : Shape) (n : ℕ) := colSp (IP p n true) ⊔ colSp (IP p n false)
-def channels (p : Shape) (n : ℕ) := colSp (IH p n true) ⊔ colSp (IH p n false)
-
-theorem ip_le_primal (b : Bool) : colSp (IP p n b)≤primal p n := by
-  cases b; exact le_sup_right; exact le_sup_left
-
-theorem ih_le_channels (b : Bool) : colSp (IH p n b)≤channels p n := by
-  cases b; exact le_sup_right; exact le_sup_left
-
-theorem channels_proj (b : Bool) : channels p n ≤ LinearMap.ker (IP p n b)ᵀ.mulVecLin := by
-  have hi (i : Bool) : colSp (IH p n i) ≤ LinearMap.ker (IP p n b)ᵀ.mulVecLin := by
-    rintro x ⟨y,rfl⟩
-    change (IP p n b)ᵀ *ᵥ (IH p n i *ᵥ y) = _
-    rw [mulVec_mulVec, IP_IH, Matrix.zero_mulVec]
-  exact sup_le (hi _) (hi _)
-
-theorem primal_proj (b : Bool) : primal p n ≤ LinearMap.ker (IH p n b)ᵀ.mulVecLin := by
-  have hi (i : Bool) : colSp (IP p n i) ≤ LinearMap.ker (IH p n b)ᵀ.mulVecLin := by
-    rintro x ⟨y,rfl⟩
-    change (IH p n b)ᵀ *ᵥ (IP p n i *ᵥ y) = _
-    rw [mulVec_mulVec, IH_IP, Matrix.zero_mulVec]
-  exact sup_le (hi _) (hi _)
-
-theorem channels_disjoint : Disjoint (primal p n) (channels p n) := by
-  rw [disjoint_iff_inf_le]
-  rintro x ⟨hx,hy⟩
-  have he (b : Bool) : (IP p n b)ᵀ *ᵥ x = 0 := channels_proj b hy
-  have hf (b : Bool) : (IH p n b)ᵀ *ᵥ x = 0 := primal_proj b hx
-  have hh := ip_decomp (show Dir p n from x)
-  simp_rw [he,hf,mulVec_zero,add_zero, Finset.sum_const_zero] at hh
-  rw [← hh]
-  exact Submodule.zero_mem _
-
-/-- prSmall a z consists of the pure-primal coordinates kept by the small
-table. -/
-def prSmall (a : Plan p n) (z : Place p) :=
-  (sPin a z true).map (IP p n true).mulVecLin ⊔
-    (sPin a z false).map (IP p n false).mulVecLin
-
-theorem prSmall_le (a : Plan p n) (z : Place p) : prSmall a z≤primal p n := by
-  apply sup_le_sup <;> rintro x ⟨x,h,rfl⟩ <;> exact ⟨x,rfl⟩
-
-theorem prSmall_dim (a : Plan p n) (z : Place p) :
-    dim (prSmall a z)≤2 * planRank a := by
-  rw [two_mul]
-  have hh (i : Bool) :
-      dim ((sPin a z i).map (IP p n i).mulVecLin) ≤ planRank a :=
-    (Submodule.finrank_map_le ..).trans ((sPin_dim ..).trans (dim_le_plan a z))
-  exact (Submodule.finrank_add_le_finrank_add_finrank ..).trans (Nat.add_le_add (hh _) (hh _))
-
-theorem prSmall_table (a : Plan p n) (z : Place p) :
-    tabSpace a z = prSmall a z ⊔ channels p n := by
-  unfold tabSpace halfTable prSmall channels
-  ac_rfl
-
-theorem keyPlane (v : Volley p n I) (t : Tagging p I) (z : Place p) :
-    v.keyPlan t z≤ primal p n := by
-  unfold Volley.keyPlan colSp
-  rw [range_mulVecLin]
-  apply Submodule.span_le.mpr
-  rintro x ⟨j,rfl⟩
-  exact (show colSp (IP p n _) ≤ primal p n from ip_le_primal (v.obj j.val))
-    (show v.rayLoc j.val∈colSp (IP p n _) from ⟨_,rfl⟩)
-
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.RealizationConditions
+
+namespace OAI
+
+/-! # Primal Channel Decomposition -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open scoped BigOperators
+open Matrix Submodule
+variable {I : Type} [Fintype I]
+
+/-- Onto projection in coordinates, killing a specified disjoint subspace. -/
+structure ProjData (S T : Space (Vec I)) (A : Mat I I) : Prop where
+  onto (x) : A *ᵥ x ∈ S
+  fixes x : x ∈ S → A *ᵥ x=x
+  kills x : x∈T → A *ᵥ x=0
+
+theorem proj_exists (S T : Space (Vec I)) (h : Disjoint S T) :
+    ∃ A, ProjData S T A := by
+  classical
+  obtain ⟨A,hA⟩ := mat_left_inv (inj_fromCols (pack_inj S) (pack_inj T)
+    (by rw [colSp_pack, colSp_pack]; exact h))
+  let B := A.toRows₁
+  let C := A.toRows₂
+  have he : fromRows B C * fromCols (pack S) (pack T)=1 := by
+    rw [show fromRows B C=A from Matrix.fromRows_toRows A,hA]
+  rw [Matrix.fromRows_mul_fromCols, ← Matrix.fromBlocks_one] at he
+  have hb : B*pack S=1 := congrArg Matrix.toBlocks₁₁ he
+  have hg : B*pack T=0 := congrArg Matrix.toBlocks₁₂ he
+  refine ⟨pack S*B,fun x => ?_,fun x hx => ?_,fun x hx => ?_⟩
+  · rw [←mulVec_mulVec]
+    exact (pack_mem_iff ..).mpr ⟨_,rfl⟩
+  · obtain ⟨x,rfl⟩ := (pack_mem_iff ..).mp hx
+    rw [←mulVec_mulVec, mulVec_mulVec _ B, hb,one_mulVec]
+  · obtain ⟨x,rfl⟩ := (pack_mem_iff ..).mp hx
+    rw [←mulVec_mulVec,mulVec_mulVec _ B,hg,zero_mulVec,mulVec_zero]
+
+theorem rank_maps {J : Type} [Fintype J] {A : Mat I J} (S : Space (Vec I))
+    (ha : ∀ x,A *ᵥ x∈ S) : A.rank ≤ dim S :=
+  Submodule.finrank_mono (show colSp A ≤ S by
+    rintro x ⟨x,rfl⟩; exact ha x)
+
+theorem evmat_addM {J : Type} [Fintype J] (A B : Mat I J) (x y) :
+    evmat (A+B) x y = evmat A x y+evmat B x y := by rw [←mpair_outer,mpair_add,
+      mpair_outer,mpair_outer]
+
+theorem evmat_subM {J : Type} [Fintype J] (A B : Mat I J) (x y) :
+    evmat (A-B) x y = evmat A x y-evmat B x y := by
+  rw [ZModModule.sub_eq_add, ZModModule.sub_eq_add, evmat_addM]
+
+variable {p : Shape} {n : ℕ}
+
+/-- aggregate primal (resp. channel) directions in a unit. -/
+def primal (p : Shape) (n : ℕ) := colSp (IP p n true) ⊔ colSp (IP p n false)
+def channels (p : Shape) (n : ℕ) := colSp (IH p n true) ⊔ colSp (IH p n false)
+
+theorem ip_le_primal (b : Bool) : colSp (IP p n b)≤primal p n := by
+  cases b; exact le_sup_right; exact le_sup_left
+
+theorem ih_le_channels (b : Bool) : colSp (IH p n b)≤channels p n := by
+  cases b; exact le_sup_right; exact le_sup_left
+
+theorem channels_proj (b : Bool) : channels p n ≤ LinearMap.ker (IP p n b)ᵀ.mulVecLin := by
+  have hi (i : Bool) : colSp (IH p n i) ≤ LinearMap.ker (IP p n b)ᵀ.mulVecLin := by
+    rintro x ⟨y,rfl⟩
+    change (IP p n b)ᵀ *ᵥ (IH p n i *ᵥ y) = _
+    rw [mulVec_mulVec, IP_IH, Matrix.zero_mulVec]
+  exact sup_le (hi _) (hi _)
+
+theorem primal_proj (b : Bool) : primal p n ≤ LinearMap.ker (IH p n b)ᵀ.mulVecLin := by
+  have hi (i : Bool) : colSp (IP p n i) ≤ LinearMap.ker (IH p n b)ᵀ.mulVecLin := by
+    rintro x ⟨y,rfl⟩
+    change (IH p n b)ᵀ *ᵥ (IP p n i *ᵥ y) = _
+    rw [mulVec_mulVec, IH_IP, Matrix.zero_mulVec]
+  exact sup_le (hi _) (hi _)
+
+theorem channels_disjoint : Disjoint (primal p n) (channels p n) := by
+  rw [disjoint_iff_inf_le]
+  rintro x ⟨hx,hy⟩
+  have he (b : Bool) : (IP p n b)ᵀ *ᵥ x = 0 := channels_proj b hy
+  have hf (b : Bool) : (IH p n b)ᵀ *ᵥ x = 0 := primal_proj b hx
+  have hh := ip_decomp (show Dir p n from x)
+  simp_rw [he,hf,mulVec_zero,add_zero, Finset.sum_const_zero] at hh
+  rw [← hh]
+  exact Submodule.zero_mem _
+
+/-- prSmall a z consists of the pure-primal coordinates kept by the small
+table. -/
+def prSmall (a : Plan p n) (z : Place p) :=
+  (sPin a z true).map (IP p n true).mulVecLin ⊔
+    (sPin a z false).map (IP p n false).mulVecLin
+
+theorem prSmall_le (a : Plan p n) (z : Place p) : prSmall a z≤primal p n := by
+  apply sup_le_sup <;> rintro x ⟨x,h,rfl⟩ <;> exact ⟨x,rfl⟩
+
+theorem prSmall_dim (a : Plan p n) (z : Place p) :
+    dim (prSmall a z)≤2 * planRank a := by
+  rw [two_mul]
+  have hh (i : Bool) :
+      dim ((sPin a z i).map (IP p n i).mulVecLin) ≤ planRank a :=
+    (Submodule.finrank_map_le ..).trans ((sPin_dim ..).trans (dim_le_plan a z))
+  exact (Submodule.finrank_add_le_finrank_add_finrank ..).trans (Nat.add_le_add (hh _) (hh _))
+
+theorem prSmall_table (a : Plan p n) (z : Place p) :
+    tabSpace a z = prSmall a z ⊔ channels p n := by
+  unfold tabSpace halfTable prSmall channels
+  ac_rfl
+
+theorem keyPlane (v : Volley p n I) (t : Tagging p I) (z : Place p) :
+    v.keyPlan t z≤ primal p n := by
+  unfold Volley.keyPlan colSp
+  rw [range_mulVecLin]
+  apply Submodule.span_le.mpr
+  rintro x ⟨j,rfl⟩
+  exact (show colSp (IP p n _) ≤ primal p n from ip_le_primal (v.obj j.val))
+    (show v.rayLoc j.val∈colSp (IP p n _) from ⟨_,rfl⟩)
+
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/PrimalChannelTests.lean

@@ -1,158 +1,158 @@
-import OAI.Combinatorics.HadwigerCounterexample.GramCharacterQuotients
-
-namespace OAI
-
-/-! # Primal Channel Tests -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Matrix LinearMap Module Submodule Finset
-open scoped BigOperators
-variable {p : Shape} {n N : ℕ}
-
-private theorem cp_rep (f : Module.Dual F (Cross p n)) :
-    ∃ M : Cross p n,cpDual p M=f := by
-  classical
-  let B : Cross p n →ₗ[F] Module.Dual F (Cross p n) := {
-    toFun := cpDual p
-    map_add' := by
-      intro x y
-      refine LinearMap.ext fun w => ?_
-      rw [LinearMap.add_apply]
-      simp only [cpDual_val,Pi.add_apply,mpair_add, Finset.sum_add_distrib]
-    map_smul' := by
-      intro a x
-      refine LinearMap.ext fun w => ?_
-      rw [LinearMap.smul_apply]
-      simp only [cpDual_val,Pi.smul_apply,mpair_smul,RingHom.id_apply,smul_eq_mul,Finset.mul_sum] }
-  have hb : Function.Injective B := by
-    rw [← LinearMap.ker_eq_bot]
-    refine le_bot_iff.mp (fun x hx => ?_)
-    have h1 : x = 0 := by
-      funext i
-      apply mpair_nondeg
-      refine LinearMap.ext fun y => ?_
-      change cpDual p x=0 at hx
-      have h := LinearMap.congr_fun hx (Pi.single i y)
-      rw [cpDual_val,Finset.sum_eq_single i] at h
-      · rwa [Pi.single_eq_same] at h
-      · intro j _ hj; simp [hj]
-      simp
-    rw [h1]; exact Submodule.zero_mem _
-  exact rk_surj.mpr ((rk_inj.mp hb).trans Subspace.dual_finrank_eq.symm) f
-
-abbrev CheckOne (p : Shape) (n : ℕ) :=
-  Place p → Bool → Bool → Mat (Chan p) (Row p n)
-abbrev CheckGram (p : Shape) (n : ℕ) :=
-  CheckOne p n × CheckOne p n
-instance cgOneFin (p : Shape) (n : ℕ) : Fintype (CheckOne p n) := by
-  classical
-  letI : Fintype (Mat (Chan p) (Row p n)) := inferInstance
-  letI : Fintype (Bool → Bool → Mat (Chan p) (Row p n)) := inferInstance
-  exact inferInstance
-instance cgFin (p : Shape) (n : ℕ) : Fintype (CheckGram p n) := inferInstance
-
-def testgram (p : Shape) {n} : Cross p n →ₗ[F] CheckGram p n where
-  toFun A := (scalarBlocks p A, scalarBlocks p (reciprocal p A))
-  map_add' A B := by
-    apply Prod.ext <;>
-    · ext; simp only [Pi.add_apply,Prod.fst_add,Prod.snd_add,
-        scalarBlocks,channelOut,reciprocal,Matrix.add_apply,Matrix.add_mul,Matrix.transpose_add]
-  map_smul' a A := by
-    apply Prod.ext <;>
-    · ext; simp only [Pi.smul_apply,Prod.smul_fst,Prod.smul_snd,
-        scalarBlocks,channelOut,reciprocal,Matrix.smul_apply,Matrix.smul_mul,Matrix.transpose_smul,
-        RingHom.id_apply]
-
-theorem checkgram_dim :
-    dim (CheckGram p n)=16*ncComp p*p.h*Fintype.card (Row p n) := by
-  classical
-  let r := p.h*Fintype.card (Row p n)
-  let T := Mat (Chan p) (Row p n)
-  have hf : finrank F T=r := (dim_mat _ _).trans (by simp [r,Chan])
-  have hg {I V : Type} [Fintype I] [AddCommGroup V] [Module F V] [FiniteDimensional F V] :
-      finrank F (I→V) = Fintype.card I * finrank F V := by
-    rw [finrank_pi_fintype]; simp
-  have h : finrank F (CheckOne p n)=8*ncComp p*r := by
-    unfold CheckOne
-    rw [hg,hg,hg,hf]
-    simp [ncComp,Place]
-    ring
-  unfold CheckGram dim
-  rw [Module.finrank_prod,h]
-  unfold r; ring
-
-theorem indicator_test {V A : Type} [Fintype A] [AddCommGroup V] [Module F V]
-    [Fintype V] (s : A → V) (w : Wgt A) (hw : IsLaw w) (ε : ℝ) (he : 0≤ε)
-    (hc : ∀ f : Module.Dual F V, let Y := avg w (fun x => wsign (f (s x))); Y=1 ∨ |Y|≤ε) :
-    bp (-(dim V:ℝ))- ε ≤ pr w (fun x => s x=0) := by
-  classical
-  let T := Module.Dual F V
-  have : Finite T := Finite.of_injective _ DFunLike.coe_injective
-  let : Fintype T := Fintype.ofFinite T
-  have h (v : V) : ind (v=0) = avg unif (fun f : T => wsign (f v)) := by
-    have h := wsign_lin (Module.evalEquiv F V v)
-    rw [map_eq_zero_iff _ (Module.evalEquiv F V).injective] at h
-    exact h.symm
-  unfold pr
-  simp_rw [h]
-  rw [avg_avg]
-  let E (v : T) := ind (v=0)
-  have hE : avg unif E = bp (-(dim V:ℝ)) := by
-    change pr unif (fun v : T => v=0)=_
-    rw [pr_point',unif_apply,card_space,
-      show dim T=dim V from Subspace.dual_finrank_eq,bp_neg]
-  rw [← hE,show avg unif E - ε= avg unif (fun v : T => E v-ε) from (by
-    rw [avg_sub,unif_law.avg_const])]
-  refine avg_mono unif_law.nz fun x => ?_
-  by_cases hh : x=0
-  · subst x
-    change ind (0= (0:T))-ε ≤ avg w (fun _ => wsign 0)
-    rw [ind_one rfl,hw.avg_const,wsign_zero]; linarith
-  unfold E
-  rw [ind_zero hh,zero_sub]
-  rcases hc x with hi|hi
-  · rw [hi]; linarith
-  exact (abs_le.mp hi).1
-
-theorem gram_hit (Q : Cross p n) {u w : Wgt (UnitType p n N)}
-    (hu : IsLaw u) (hw : IsLaw w) {f b : Pin p n N}
-    (hc : f.clear 0.05 u) (hd : b.clear 0.05 w)
-    (h : ∀ x,u x≠0 → ∀ y,w y≠0 → rowAgree f.sp (actual p x y) Q ∧
-      rowAgree b.sp (actual p y x) (reciprocal p Q))
-    (hN : 100 ≤ N) (hT : (dim (CheckGram p n) : ℝ)≤0.01*N) :
-    hit N ≤ pr (pairW u w) (fun x =>
-      testgram p (actual p x.1 x.2)=testgram p Q) := by
-  classical
-  let v := pairW u w
-  let s (x : UnitType p n N × UnitType p n N) := testgram p (actual p x.1 x.2 - Q)
-  have hh (g : Module.Dual F (CheckGram p n)) :
-      let Y := avg v (fun x => wsign (g (s x)))
-      Y=1 ∨ |Y|≤bp (-0.45*N) := by
-    obtain ⟨M,hM⟩ := cp_rep (g ∘ₗ testgram p)
-    have hf x := LinearMap.congr_fun hM x
-    have he x : g (s x) = cpDual p M _ := (hf (actual p x.1 x.2-Q)).symm
-    dsimp only
-    simp_rw [he]
-    exact gramCharacter Q M hu hw hc hd h
-  have hg := indicator_test s v (pairW_law hu hw) (bp (-0.45*N)) (bp_pos _).le hh
-  have he : pr v (fun x => s x=0)=pr v (fun x => testgram p (actual p x.1 x.2)=testgram p Q) := by
-    apply congrArg (pr v)
-    funext x; apply propext
-    unfold s
-    have he (A : Cross p n) : testgram p (A+Q) = testgram p A+testgram p Q := (testgram p).map_add' _ _
-    rw [show actual p x.1 x.2-Q=actual p x.1 x.2+Q from ZModModule.sub_eq_add ..,he, ← ZModModule.sub_eq_add,sub_eq_zero]
-  rw [he] at hg
-  refine le_trans ?_ hg
-  have hn : 100≤(N:ℝ) := by exact_mod_cast hN
-  unfold hit
-  have heq := bp_le (show -0.45*N≤-0.02*(N:ℝ) by linarith only [hn])
-  have heq' : 2*bp (-0.02*N) ≤ bp (-(dim (CheckGram p n):ℝ)) := by
-    rw [← bp_one,← bp_add]; apply bp_le; linarith only [hn,hT]
-  linarith only [heq,heq']
-
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.GramCharacterQuotients
+
+namespace OAI
+
+/-! # Primal Channel Tests -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Matrix LinearMap Module Submodule Finset
+open scoped BigOperators
+variable {p : Shape} {n N : ℕ}
+
+private theorem cp_rep (f : Module.Dual F (Cross p n)) :
+    ∃ M : Cross p n,cpDual p M=f := by
+  classical
+  let B : Cross p n →ₗ[F] Module.Dual F (Cross p n) := {
+    toFun := cpDual p
+    map_add' := by
+      intro x y
+      refine LinearMap.ext fun w => ?_
+      rw [LinearMap.add_apply]
+      simp only [cpDual_val,Pi.add_apply,mpair_add, Finset.sum_add_distrib]
+    map_smul' := by
+      intro a x
+      refine LinearMap.ext fun w => ?_
+      rw [LinearMap.smul_apply]
+      simp only [cpDual_val,Pi.smul_apply,mpair_smul,RingHom.id_apply,smul_eq_mul,Finset.mul_sum] }
+  have hb : Function.Injective B := by
+    rw [← LinearMap.ker_eq_bot]
+    refine le_bot_iff.mp (fun x hx => ?_)
+    have h1 : x = 0 := by
+      funext i
+      apply mpair_nondeg
+      refine LinearMap.ext fun y => ?_
+      change cpDual p x=0 at hx
+      have h := LinearMap.congr_fun hx (Pi.single i y)
+      rw [cpDual_val,Finset.sum_eq_single i] at h
+      · rwa [Pi.single_eq_same] at h
+      · intro j _ hj; simp [hj]
+      simp
+    rw [h1]; exact Submodule.zero_mem _
+  exact rk_surj.mpr ((rk_inj.mp hb).trans Subspace.dual_finrank_eq.symm) f
+
+abbrev CheckOne (p : Shape) (n : ℕ) :=
+  Place p → Bool → Bool → Mat (Chan p) (Row p n)
+abbrev CheckGram (p : Shape) (n : ℕ) :=
+  CheckOne p n × CheckOne p n
+instance cgOneFin (p : Shape) (n : ℕ) : Fintype (CheckOne p n) := by
+  classical
+  letI : Fintype (Mat (Chan p) (Row p n)) := inferInstance
+  letI : Fintype (Bool → Bool → Mat (Chan p) (Row p n)) := inferInstance
+  exact inferInstance
+instance cgFin (p : Shape) (n : ℕ) : Fintype (CheckGram p n) := inferInstance
+
+def testgram (p : Shape) {n} : Cross p n →ₗ[F] CheckGram p n where
+  toFun A := (scalarBlocks p A, scalarBlocks p (reciprocal p A))
+  map_add' A B := by
+    apply Prod.ext <;>
+    · ext; simp only [Pi.add_apply,Prod.fst_add,Prod.snd_add,
+        scalarBlocks,channelOut,reciprocal,Matrix.add_apply,Matrix.add_mul,Matrix.transpose_add]
+  map_smul' a A := by
+    apply Prod.ext <;>
+    · ext; simp only [Pi.smul_apply,Prod.smul_fst,Prod.smul_snd,
+        scalarBlocks,channelOut,reciprocal,Matrix.smul_apply,Matrix.smul_mul,Matrix.transpose_smul,
+        RingHom.id_apply]
+
+theorem checkgram_dim :
+    dim (CheckGram p n)=16*ncComp p*p.h*Fintype.card (Row p n) := by
+  classical
+  let r := p.h*Fintype.card (Row p n)
+  let T := Mat (Chan p) (Row p n)
+  have hf : finrank F T=r := (dim_mat _ _).trans (by simp [r,Chan])
+  have hg {I V : Type} [Fintype I] [AddCommGroup V] [Module F V] [FiniteDimensional F V] :
+      finrank F (I→V) = Fintype.card I * finrank F V := by
+    rw [finrank_pi_fintype]; simp
+  have h : finrank F (CheckOne p n)=8*ncComp p*r := by
+    unfold CheckOne
+    rw [hg,hg,hg,hf]
+    simp [ncComp,Place]
+    ring
+  unfold CheckGram dim
+  rw [Module.finrank_prod,h]
+  unfold r; ring
+
+theorem indicator_test {V A : Type} [Fintype A] [AddCommGroup V] [Module F V]
+    [Fintype V] (s : A → V) (w : Wgt A) (hw : IsLaw w) (ε : ℝ) (he : 0≤ε)
+    (hc : ∀ f : Module.Dual F V, let Y := avg w (fun x => wsign (f (s x))); Y=1 ∨ |Y|≤ε) :
+    bp (-(dim V:ℝ))- ε ≤ pr w (fun x => s x=0) := by
+  classical
+  let T := Module.Dual F V
+  have : Finite T := Finite.of_injective _ DFunLike.coe_injective
+  let : Fintype T := Fintype.ofFinite T
+  have h (v : V) : ind (v=0) = avg unif (fun f : T => wsign (f v)) := by
+    have h := wsign_lin (Module.evalEquiv F V v)
+    rw [map_eq_zero_iff _ (Module.evalEquiv F V).injective] at h
+    exact h.symm
+  unfold pr
+  simp_rw [h]
+  rw [avg_avg]
+  let E (v : T) := ind (v=0)
+  have hE : avg unif E = bp (-(dim V:ℝ)) := by
+    change pr unif (fun v : T => v=0)=_
+    rw [pr_point',unif_apply,card_space,
+      show dim T=dim V from Subspace.dual_finrank_eq,bp_neg]
+  rw [← hE,show avg unif E - ε= avg unif (fun v : T => E v-ε) from (by
+    rw [avg_sub,unif_law.avg_const])]
+  refine avg_mono unif_law.nz fun x => ?_
+  by_cases hh : x=0
+  · subst x
+    change ind (0= (0:T))-ε ≤ avg w (fun _ => wsign 0)
+    rw [ind_one rfl,hw.avg_const,wsign_zero]; linarith
+  unfold E
+  rw [ind_zero hh,zero_sub]
+  rcases hc x with hi|hi
+  · rw [hi]; linarith
+  exact (abs_le.mp hi).1
+
+theorem gram_hit (Q : Cross p n) {u w : Wgt (UnitType p n N)}
+    (hu : IsLaw u) (hw : IsLaw w) {f b : Pin p n N}
+    (hc : f.clear 0.05 u) (hd : b.clear 0.05 w)
+    (h : ∀ x,u x≠0 → ∀ y,w y≠0 → rowAgree f.sp (actual p x y) Q ∧
+      rowAgree b.sp (actual p y x) (reciprocal p Q))
+    (hN : 100 ≤ N) (hT : (dim (CheckGram p n) : ℝ)≤0.01*N) :
+    hit N ≤ pr (pairW u w) (fun x =>
+      testgram p (actual p x.1 x.2)=testgram p Q) := by
+  classical
+  let v := pairW u w
+  let s (x : UnitType p n N × UnitType p n N) := testgram p (actual p x.1 x.2 - Q)
+  have hh (g : Module.Dual F (CheckGram p n)) :
+      let Y := avg v (fun x => wsign (g (s x)))
+      Y=1 ∨ |Y|≤bp (-0.45*N) := by
+    obtain ⟨M,hM⟩ := cp_rep (g ∘ₗ testgram p)
+    have hf x := LinearMap.congr_fun hM x
+    have he x : g (s x) = cpDual p M _ := (hf (actual p x.1 x.2-Q)).symm
+    dsimp only
+    simp_rw [he]
+    exact gramCharacter Q M hu hw hc hd h
+  have hg := indicator_test s v (pairW_law hu hw) (bp (-0.45*N)) (bp_pos _).le hh
+  have he : pr v (fun x => s x=0)=pr v (fun x => testgram p (actual p x.1 x.2)=testgram p Q) := by
+    apply congrArg (pr v)
+    funext x; apply propext
+    unfold s
+    have he (A : Cross p n) : testgram p (A+Q) = testgram p A+testgram p Q := (testgram p).map_add' _ _
+    rw [show actual p x.1 x.2-Q=actual p x.1 x.2+Q from ZModModule.sub_eq_add ..,he, ← ZModModule.sub_eq_add,sub_eq_zero]
+  rw [he] at hg
+  refine le_trans ?_ hg
+  have hn : 100≤(N:ℝ) := by exact_mod_cast hN
+  unfold hit
+  have heq := bp_le (show -0.45*N≤-0.02*(N:ℝ) by linarith only [hn])
+  have heq' : 2*bp (-0.02*N) ≤ bp (-(dim (CheckGram p n):ℝ)) := by
+    rw [← bp_one,← bp_add]; apply bp_le; linarith only [hn,hT]
+  linarith only [heq,heq']
+
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/PrimalSpaceCompression.lean

@@ -1,199 +1,199 @@
-import OAI.Combinatorics.HadwigerCounterexample.RankEfficientDecomposition
-
-namespace OAI
-
-/-! # Primal Space Compression -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Matrix LinearMap Module Submodule Finset
-open scoped BigOperators
-variable {p : Shape} {n : ℕ} {I J : Type} [Fintype I] [Fintype J]
-
-private theorem exists_cover (S : J→Space (Vec I)) (D : ℕ) (h : ∀ j,dim (S j)≤D) :
-    ∃ A : Space (Vec I),(∀ j,S j ≤ A) ∧ dim A≤Fintype.card J*D := by
-  classical
-  have hh (s : Finset J) :
-      ∃ A : Space (Vec I),(∀ j∈s,S j≤A) ∧ dim A≤s.card*D := by
-    induction s using Finset.induction with
-    | empty => exact ⟨⊥,by simp, by simp [dim]⟩
-    | insert a s ha ih =>
-      obtain ⟨A,hA,hD⟩ := ih
-      refine ⟨S a⊔A,fun j hj => ?_,?_⟩
-      · rcases Finset.mem_insert.mp hj with rfl|g
-        · exact le_sup_left
-        exact (hA _ g).trans le_sup_right
-      simpa only [Finset.card_insert_of_notMem ha,Nat.add_mul,one_mul,add_comm D] using
-        ((Submodule.finrank_add_le_finrank_add_finrank (S a) A).trans (add_le_add (h a) hD))
-  simpa only [Finset.mem_univ,true_imp_iff,card_univ] using hh Finset.univ
-
-theorem compact_endo (S T : Space (Vec I)) :
-    ∃ A : Mat I I,(∀ x∈S,A *ᵥ x=x) ∧ (∀ x∈T,Aᵀ *ᵥ x=x) ∧ A.rank≤dim S+dim T := by
-  classical
-  obtain ⟨A,hA⟩ := proj_exists S ⊥ disjoint_bot_right
-  obtain ⟨B,hB⟩ := proj_exists T ⊥ disjoint_bot_right
-  refine ⟨A+Bᵀ * (1-A),fun x hx => ?_,fun x hx => ?_,?_⟩
-  · rw [Matrix.add_mulVec,←Matrix.mulVec_mulVec,Matrix.sub_mulVec,hA.fixes x hx,
-      Matrix.one_mulVec,sub_self,Matrix.mulVec_zero,add_zero]
-  · rw [Matrix.transpose_add,Matrix.add_mulVec,Matrix.transpose_mul,Matrix.transpose_transpose,
-      ← mulVec_mulVec,hB.fixes x hx,Matrix.transpose_sub,Matrix.sub_mulVec,Matrix.transpose_one,
-      Matrix.one_mulVec,add_sub_cancel]
-  exact (mrk_add_le ..).trans (add_le_add (rank_maps S hA.onto) ((Matrix.rank_mul_le_left ..).trans
-    (by rw [Matrix.rank_transpose]; exact rank_maps T hB.onto)))
-
-abbrev Sel (p : Shape) := SelIdx p.b p.j
-abbrev Nendo (p : Shape) (n : ℕ) := Block p.g→ Mat (Fin n) (Fin n)
-def iFix (p : Shape) (n : ℕ) : Mat (Row p n) (Sel p) := embedMat (fun s => (s,none))
-def iCoeff (p : Shape) (n : ℕ) (s : Sel p) (d : Block p.g) :
-    Mat (Row p n) (Fin n) := embedMat (fun i => (s,some (d,i)))
-
-/-- induced row vector transform. -/
-def rowShrink (p : Shape) {n} (A : Nendo p n) : Mat (Row p n) (Row p n) :=
-  iFix p n*(iFix p n)ᵀ +
-  ∑ i : Sel p,∑ d : Block p.g,iCoeff p n i d*A d*(iCoeff p n i d)ᵀ
-
-def readCoeff (p : Shape) {n} (s : Sel p) (d : Block p.g) (v : Ray p n) :=
-  fun i => v (s,some (d,i))
-
-theorem readCoeff_val (s : Sel p) (d : Block p.g) (v : Ray p n) :
-    (iCoeff p n s d)ᵀ *ᵥ v=readCoeff p s d v := embedMatT _ _
-
-theorem shrink_transpose (A : Nendo p n) :
-    (rowShrink p A)ᵀ=rowShrink p (fun i => (A i)ᵀ) := by
-  simp only [rowShrink,Matrix.transpose_add,Matrix.transpose_mul,
-    Matrix.transpose_sum,Matrix.transpose_transpose,Matrix.mul_assoc]
-
-private theorem coeff_none (A : Nendo p n) (v : Ray p n) (s : Sel p) :
-    (rowShrink p A *ᵥ v) (s,none)=v (s,none) := by
-  classical
-  simp only [rowShrink,Matrix.add_mulVec, Matrix.sum_mulVec,←Matrix.mulVec_mulVec,readCoeff_val]
-  unfold iFix iCoeff
-  rw [embedMatT]
-  simp [embedMat,Matrix.mulVec,dotProduct,Finset.sum_apply,Matrix.mul_apply]
-
-set_option maxHeartbeats 600000 in
-private theorem coeff_some (A : Nendo p n) (v : Ray p n) (s : Sel p)
-    (d : Block p.g) (i : Fin n) :
-    (rowShrink p A *ᵥ v) (s,some (d,i))=(A d *ᵥ (readCoeff p s d v)) i := by
-  classical
-  simp only [rowShrink,Matrix.add_mulVec, Matrix.sum_mulVec,←Matrix.mulVec_mulVec,readCoeff_val]
-  simp only [Pi.add_apply,Finset.sum_apply]
-  have hz (x) : (iFix p n *ᵥ x) (s,some (d,i))=0 := by
-    simp [iFix,embedMat,Matrix.mulVec,dotProduct]
-  rw [hz,zero_add]
-  have hh (t : Sel p) (a : Block p.g) (x : Vec (Fin n)) :
-      (iCoeff p n t a *ᵥ x) (s,some (d,i)) =
-      if s=t then (if d=a then x i else 0) else 0 := by
-    by_cases e : s=t <;> by_cases g : d=a <;> simp [iCoeff,embedMat,Matrix.mulVec,dotProduct,e,g]
-  simp_rw [hh]
-  rw [Finset.sum_eq_single s]
-  · simp only [ite_true,Finset.sum_ite_eq,mem_univ]
-  · intro a _ ha; simp only [ite_eq_right (Ne.symm ha),Finset.sum_const_zero]
-  simp
-
-private theorem coeff_fixes (A : Nendo p n) (v : Ray p n)
-    (h : ∀ d s, A d *ᵥ (readCoeff p s d v) = readCoeff p s d v) :
-    rowShrink p A *ᵥ v=v := by
-  funext i
-  rcases i with ⟨s, _|⟨d,i⟩⟩
-  · rw [coeff_none]
-  rw [coeff_some,h]
-  rfl
-
-def nbBlock (p : Shape) := Fintype.card (Block p.g)
-def ncComp (p : Shape) := Fintype.card (Comp p.g)
-
-theorem shrink_rank (A : Nendo p n) (D : ℕ) (h : ∀ i,(A i).rank ≤ D) :
-    (rowShrink p A).rank≤ psize p+ psize p* (nbBlock p*D) := by
-  apply le_trans (mrk_add_le ..)
-  apply add_le_add
-  · exact (Matrix.rank_mul_le_left ..).trans (iFix p n).rank_le_card_width
-  refine (mrk_sum_le ..).trans ((Finset.sum_le_sum (g:=fun _ => nbBlock p*D) (fun i _ => ?_)).trans_eq
-    (by simp [psize,Sel]))
-  refine (mrk_sum_le ..).trans ((Finset.sum_le_sum (g:=fun _ => D) (fun i _ => ?_)).trans_eq
-    (by simp [nbBlock]))
-  exact ((Matrix.rank_mul_le_left ..).trans (Matrix.rank_mul_le_right ..)).trans (h i)
-
-def dbits (p : Shape) (T R : ℕ) := ncComp p*2* psize p*(T+R)
-def drow (p : Shape) (T R : ℕ) := psize p+psize p*(nbBlock p*dbits p T R)
-
-theorem shrink_both (S T : Place p → Space (Ray p n)) (K R : ℕ)
-    (hk : ∀ z,dim (S z) ≤K) (hr : ∀ z,dim (T z)≤R) :
-    ∃ A : Nendo p n,
-      (∀ z,∀ x∈S z,rowShrink p A *ᵥ x=x) ∧
-      (∀ z,∀ x∈T z,(rowShrink p A)ᵀ *ᵥ x=x) ∧
-      (rowShrink p A).rank ≤ drow p K R := by
-  classical
-  let W := Place p×Sel p
-  have hp : Fintype.card (Place p×Sel p)=ncComp p*2*psize p := by
-    simp only [Place,Fintype.card_prod,ncComp,Fintype.card_bool,psize,Sel]
-  let G d (S : Place p → Space (Ray p n)) (z : Place p×Sel p) :=
-    (S z.1).map (iCoeff p n z.2 d)ᵀ.mulVecLin
-  obtain ⟨A,hA,hT,hL⟩ :
-      ∃ A : Nendo p n,
-        (∀ d z,∀ x∈G d S z,A d *ᵥ x=x) ∧
-        (∀ d z,∀ x∈G d T z,(A d)ᵀ *ᵥ x=x) ∧ ∀ i,(A i).rank≤dbits p K R := by
-    have he (d : Block p.g) :
-        ∃ A : Mat (Fin n) (Fin n), (∀ z,∀ x∈G d S z,A *ᵥ x=x) ∧
-        (∀ z,∀ x∈G d T z,Aᵀ *ᵥ x=x) ∧ A.rank≤dbits p K R := by
-      obtain ⟨X,hX,hD⟩ := exists_cover (G d S) K (fun j => (Submodule.finrank_map_le ..).trans
-        (hk j.1))
-      obtain ⟨Y,hY,hD'⟩ := exists_cover (G d T) R (fun j => (Submodule.finrank_map_le ..).trans
-        (hr j.1))
-      obtain ⟨A,hA,hZ,hL⟩ := compact_endo X Y
-      refine ⟨A,(fun z x hx => hA x (hX z hx)),(fun z x hx => hZ x (hY z hx)),?_⟩
-      rw [hp] at hD hD'
-      exact hL.trans ((add_le_add hD hD').trans_eq (Nat.mul_add ..).symm)
-    choose A hA hZ hL using he
-    exact ⟨A,hA,hZ,hL⟩
-  have he (X : Place p → Space (Ray p n)) (z)
-      (x : Ray p n) (hx : x∈X z) (d s) : readCoeff p s d x∈ G d X (z,s) :=
-    ⟨x,hx,readCoeff_val ..⟩
-  refine ⟨A,fun z x hx => ?_,fun z x hx => ?_,shrink_rank A _ hL⟩
-  · exact coeff_fixes A x (fun d s => hA _ (z,s) _ (he S z x hx d s))
-  rw [shrink_transpose]
-  exact coeff_fixes _ _ (fun d s => hT _ (z,s) _ (he T z x hx d s))
-
-private def shrinkBase (A : Nendo p n) (v : Base p.g n) : Base p.g n :=
-  fun x => (A x.1 *ᵥ (fun j => v (x.1,j))) x.2
-
-private theorem shrink_point (A : Nendo p n) (s : Label p.b) (z : Base p.g n) :
-    rowShrink p A *ᵥ point p s z=point p s (shrinkBase (p:=p) A z) := by
-  classical
-  funext i
-  rcases i with ⟨r,_|⟨d,i⟩⟩
-  · rw [coeff_none]; rfl
-  rw [coeff_some]
-  simp only [point_eval,readCoeff,shrinkBase,Matrix.mulVec,dotProduct,
-    baseV,Option.elim',Finset.mul_sum]
-  exact Finset.sum_congr rfl fun i _ => mul_left_comm ..
-
-private theorem shrink_tag (A : Nendo p n) (l : Tag p.g) (M : Moment p n) (h : M∈Wtag p n l) :
-    liftM (rowShrink p A) (rowShrink p A) M∈Wtag p n l := by
-  classical
-  unfold Wtag at h
-  induction h using Submodule.span_induction with
-  | mem m hm =>
-    obtain ⟨s,z,hz,rfl⟩ := hm
-    simp only [mom,liftM_outer,shrink_point]
-    apply Submodule.subset_span
-    refine ⟨s,shrinkBase (p:=p) A z,?_,rfl⟩
-    intro d t hd i
-    change (A (Block.O d t) *ᵥ _) i = _
-    simp only [Matrix.mulVec,dotProduct,hz _ _ hd,mul_zero,Finset.sum_const_zero]
-  | zero => rw [map_zero]; exact Submodule.zero_mem _
-  | add x y hx hy ih ih' => rw [map_add]; exact Submodule.add_mem _ ih ih'
-  | smul a x hx ih => rw [map_smul]; exact Submodule.smul_mem _ _ ih
-
-theorem shrink_X (A : Nendo p n) (M : Profile p n) (h : M∈Xspace p n) :
-    (fun e : Comp p.g => liftM (rowShrink p A) (rowShrink p A) (M e))∈Xspace p n := by
-  obtain ⟨w,hw,rfl⟩ := mem_X.mp h
-  refine mem_X.mpr ⟨_,(fun l => shrink_tag A l _ (hw l)),?_⟩
-  funext i
-  exact (map_add (liftM (rowShrink p A) (rowShrink p A)) _ _).symm
-
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.RankEfficientDecomposition
+
+namespace OAI
+
+/-! # Primal Space Compression -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Matrix LinearMap Module Submodule Finset
+open scoped BigOperators
+variable {p : Shape} {n : ℕ} {I J : Type} [Fintype I] [Fintype J]
+
+private theorem exists_cover (S : J→Space (Vec I)) (D : ℕ) (h : ∀ j,dim (S j)≤D) :
+    ∃ A : Space (Vec I),(∀ j,S j ≤ A) ∧ dim A≤Fintype.card J*D := by
+  classical
+  have hh (s : Finset J) :
+      ∃ A : Space (Vec I),(∀ j∈s,S j≤A) ∧ dim A≤s.card*D := by
+    induction s using Finset.induction with
+    | empty => exact ⟨⊥,by simp, by simp [dim]⟩
+    | insert a s ha ih =>
+      obtain ⟨A,hA,hD⟩ := ih
+      refine ⟨S a⊔A,fun j hj => ?_,?_⟩
+      · rcases Finset.mem_insert.mp hj with rfl|g
+        · exact le_sup_left
+        exact (hA _ g).trans le_sup_right
+      simpa only [Finset.card_insert_of_notMem ha,Nat.add_mul,one_mul,add_comm D] using
+        ((Submodule.finrank_add_le_finrank_add_finrank (S a) A).trans (add_le_add (h a) hD))
+  simpa only [Finset.mem_univ,true_imp_iff,card_univ] using hh Finset.univ
+
+theorem compact_endo (S T : Space (Vec I)) :
+    ∃ A : Mat I I,(∀ x∈S,A *ᵥ x=x) ∧ (∀ x∈T,Aᵀ *ᵥ x=x) ∧ A.rank≤dim S+dim T := by
+  classical
+  obtain ⟨A,hA⟩ := proj_exists S ⊥ disjoint_bot_right
+  obtain ⟨B,hB⟩ := proj_exists T ⊥ disjoint_bot_right
+  refine ⟨A+Bᵀ * (1-A),fun x hx => ?_,fun x hx => ?_,?_⟩
+  · rw [Matrix.add_mulVec,←Matrix.mulVec_mulVec,Matrix.sub_mulVec,hA.fixes x hx,
+      Matrix.one_mulVec,sub_self,Matrix.mulVec_zero,add_zero]
+  · rw [Matrix.transpose_add,Matrix.add_mulVec,Matrix.transpose_mul,Matrix.transpose_transpose,
+      ← mulVec_mulVec,hB.fixes x hx,Matrix.transpose_sub,Matrix.sub_mulVec,Matrix.transpose_one,
+      Matrix.one_mulVec,add_sub_cancel]
+  exact (mrk_add_le ..).trans (add_le_add (rank_maps S hA.onto) ((Matrix.rank_mul_le_left ..).trans
+    (by rw [Matrix.rank_transpose]; exact rank_maps T hB.onto)))
+
+abbrev Sel (p : Shape) := SelIdx p.b p.j
+abbrev Nendo (p : Shape) (n : ℕ) := Block p.g→ Mat (Fin n) (Fin n)
+def iFix (p : Shape) (n : ℕ) : Mat (Row p n) (Sel p) := embedMat (fun s => (s,none))
+def iCoeff (p : Shape) (n : ℕ) (s : Sel p) (d : Block p.g) :
+    Mat (Row p n) (Fin n) := embedMat (fun i => (s,some (d,i)))
+
+/-- induced row vector transform. -/
+def rowShrink (p : Shape) {n} (A : Nendo p n) : Mat (Row p n) (Row p n) :=
+  iFix p n*(iFix p n)ᵀ +
+  ∑ i : Sel p,∑ d : Block p.g,iCoeff p n i d*A d*(iCoeff p n i d)ᵀ
+
+def readCoeff (p : Shape) {n} (s : Sel p) (d : Block p.g) (v : Ray p n) :=
+  fun i => v (s,some (d,i))
+
+theorem readCoeff_val (s : Sel p) (d : Block p.g) (v : Ray p n) :
+    (iCoeff p n s d)ᵀ *ᵥ v=readCoeff p s d v := embedMatT _ _
+
+theorem shrink_transpose (A : Nendo p n) :
+    (rowShrink p A)ᵀ=rowShrink p (fun i => (A i)ᵀ) := by
+  simp only [rowShrink,Matrix.transpose_add,Matrix.transpose_mul,
+    Matrix.transpose_sum,Matrix.transpose_transpose,Matrix.mul_assoc]
+
+private theorem coeff_none (A : Nendo p n) (v : Ray p n) (s : Sel p) :
+    (rowShrink p A *ᵥ v) (s,none)=v (s,none) := by
+  classical
+  simp only [rowShrink,Matrix.add_mulVec, Matrix.sum_mulVec,←Matrix.mulVec_mulVec,readCoeff_val]
+  unfold iFix iCoeff
+  rw [embedMatT]
+  simp [embedMat,Matrix.mulVec,dotProduct,Finset.sum_apply,Matrix.mul_apply]
+
+set_option maxHeartbeats 600000 in
+private theorem coeff_some (A : Nendo p n) (v : Ray p n) (s : Sel p)
+    (d : Block p.g) (i : Fin n) :
+    (rowShrink p A *ᵥ v) (s,some (d,i))=(A d *ᵥ (readCoeff p s d v)) i := by
+  classical
+  simp only [rowShrink,Matrix.add_mulVec, Matrix.sum_mulVec,←Matrix.mulVec_mulVec,readCoeff_val]
+  simp only [Pi.add_apply,Finset.sum_apply]
+  have hz (x) : (iFix p n *ᵥ x) (s,some (d,i))=0 := by
+    simp [iFix,embedMat,Matrix.mulVec,dotProduct]
+  rw [hz,zero_add]
+  have hh (t : Sel p) (a : Block p.g) (x : Vec (Fin n)) :
+      (iCoeff p n t a *ᵥ x) (s,some (d,i)) =
+      if s=t then (if d=a then x i else 0) else 0 := by
+    by_cases e : s=t <;> by_cases g : d=a <;> simp [iCoeff,embedMat,Matrix.mulVec,dotProduct,e,g]
+  simp_rw [hh]
+  rw [Finset.sum_eq_single s]
+  · simp only [ite_true,Finset.sum_ite_eq,mem_univ]
+  · intro a _ ha; simp only [ite_eq_right (Ne.symm ha),Finset.sum_const_zero]
+  simp
+
+private theorem coeff_fixes (A : Nendo p n) (v : Ray p n)
+    (h : ∀ d s, A d *ᵥ (readCoeff p s d v) = readCoeff p s d v) :
+    rowShrink p A *ᵥ v=v := by
+  funext i
+  rcases i with ⟨s, _|⟨d,i⟩⟩
+  · rw [coeff_none]
+  rw [coeff_some,h]
+  rfl
+
+def nbBlock (p : Shape) := Fintype.card (Block p.g)
+def ncComp (p : Shape) := Fintype.card (Comp p.g)
+
+theorem shrink_rank (A : Nendo p n) (D : ℕ) (h : ∀ i,(A i).rank ≤ D) :
+    (rowShrink p A).rank≤ psize p+ psize p* (nbBlock p*D) := by
+  apply le_trans (mrk_add_le ..)
+  apply add_le_add
+  · exact (Matrix.rank_mul_le_left ..).trans (iFix p n).rank_le_card_width
+  refine (mrk_sum_le ..).trans ((Finset.sum_le_sum (g:=fun _ => nbBlock p*D) (fun i _ => ?_)).trans_eq
+    (by simp [psize,Sel]))
+  refine (mrk_sum_le ..).trans ((Finset.sum_le_sum (g:=fun _ => D) (fun i _ => ?_)).trans_eq
+    (by simp [nbBlock]))
+  exact ((Matrix.rank_mul_le_left ..).trans (Matrix.rank_mul_le_right ..)).trans (h i)
+
+def dbits (p : Shape) (T R : ℕ) := ncComp p*2* psize p*(T+R)
+def drow (p : Shape) (T R : ℕ) := psize p+psize p*(nbBlock p*dbits p T R)
+
+theorem shrink_both (S T : Place p → Space (Ray p n)) (K R : ℕ)
+    (hk : ∀ z,dim (S z) ≤K) (hr : ∀ z,dim (T z)≤R) :
+    ∃ A : Nendo p n,
+      (∀ z,∀ x∈S z,rowShrink p A *ᵥ x=x) ∧
+      (∀ z,∀ x∈T z,(rowShrink p A)ᵀ *ᵥ x=x) ∧
+      (rowShrink p A).rank ≤ drow p K R := by
+  classical
+  let W := Place p×Sel p
+  have hp : Fintype.card (Place p×Sel p)=ncComp p*2*psize p := by
+    simp only [Place,Fintype.card_prod,ncComp,Fintype.card_bool,psize,Sel]
+  let G d (S : Place p → Space (Ray p n)) (z : Place p×Sel p) :=
+    (S z.1).map (iCoeff p n z.2 d)ᵀ.mulVecLin
+  obtain ⟨A,hA,hT,hL⟩ :
+      ∃ A : Nendo p n,
+        (∀ d z,∀ x∈G d S z,A d *ᵥ x=x) ∧
+        (∀ d z,∀ x∈G d T z,(A d)ᵀ *ᵥ x=x) ∧ ∀ i,(A i).rank≤dbits p K R := by
+    have he (d : Block p.g) :
+        ∃ A : Mat (Fin n) (Fin n), (∀ z,∀ x∈G d S z,A *ᵥ x=x) ∧
+        (∀ z,∀ x∈G d T z,Aᵀ *ᵥ x=x) ∧ A.rank≤dbits p K R := by
+      obtain ⟨X,hX,hD⟩ := exists_cover (G d S) K (fun j => (Submodule.finrank_map_le ..).trans
+        (hk j.1))
+      obtain ⟨Y,hY,hD'⟩ := exists_cover (G d T) R (fun j => (Submodule.finrank_map_le ..).trans
+        (hr j.1))
+      obtain ⟨A,hA,hZ,hL⟩ := compact_endo X Y
+      refine ⟨A,(fun z x hx => hA x (hX z hx)),(fun z x hx => hZ x (hY z hx)),?_⟩
+      rw [hp] at hD hD'
+      exact hL.trans ((add_le_add hD hD').trans_eq (Nat.mul_add ..).symm)
+    choose A hA hZ hL using he
+    exact ⟨A,hA,hZ,hL⟩
+  have he (X : Place p → Space (Ray p n)) (z)
+      (x : Ray p n) (hx : x∈X z) (d s) : readCoeff p s d x∈ G d X (z,s) :=
+    ⟨x,hx,readCoeff_val ..⟩
+  refine ⟨A,fun z x hx => ?_,fun z x hx => ?_,shrink_rank A _ hL⟩
+  · exact coeff_fixes A x (fun d s => hA _ (z,s) _ (he S z x hx d s))
+  rw [shrink_transpose]
+  exact coeff_fixes _ _ (fun d s => hT _ (z,s) _ (he T z x hx d s))
+
+private def shrinkBase (A : Nendo p n) (v : Base p.g n) : Base p.g n :=
+  fun x => (A x.1 *ᵥ (fun j => v (x.1,j))) x.2
+
+private theorem shrink_point (A : Nendo p n) (s : Label p.b) (z : Base p.g n) :
+    rowShrink p A *ᵥ point p s z=point p s (shrinkBase (p:=p) A z) := by
+  classical
+  funext i
+  rcases i with ⟨r,_|⟨d,i⟩⟩
+  · rw [coeff_none]; rfl
+  rw [coeff_some]
+  simp only [point_eval,readCoeff,shrinkBase,Matrix.mulVec,dotProduct,
+    baseV,Option.elim',Finset.mul_sum]
+  exact Finset.sum_congr rfl fun i _ => mul_left_comm ..
+
+private theorem shrink_tag (A : Nendo p n) (l : Tag p.g) (M : Moment p n) (h : M∈Wtag p n l) :
+    liftM (rowShrink p A) (rowShrink p A) M∈Wtag p n l := by
+  classical
+  unfold Wtag at h
+  induction h using Submodule.span_induction with
+  | mem m hm =>
+    obtain ⟨s,z,hz,rfl⟩ := hm
+    simp only [mom,liftM_outer,shrink_point]
+    apply Submodule.subset_span
+    refine ⟨s,shrinkBase (p:=p) A z,?_,rfl⟩
+    intro d t hd i
+    change (A (Block.O d t) *ᵥ _) i = _
+    simp only [Matrix.mulVec,dotProduct,hz _ _ hd,mul_zero,Finset.sum_const_zero]
+  | zero => rw [map_zero]; exact Submodule.zero_mem _
+  | add x y hx hy ih ih' => rw [map_add]; exact Submodule.add_mem _ ih ih'
+  | smul a x hx ih => rw [map_smul]; exact Submodule.smul_mem _ _ ih
+
+theorem shrink_X (A : Nendo p n) (M : Profile p n) (h : M∈Xspace p n) :
+    (fun e : Comp p.g => liftM (rowShrink p A) (rowShrink p A) (M e))∈Xspace p n := by
+  obtain ⟨w,hw,rfl⟩ := mem_X.mp h
+  refine mem_X.mpr ⟨_,(fun l => shrink_tag A l _ (hw l)),?_⟩
+  funext i
+  exact (map_add (liftM (rowShrink p A) (rowShrink p A)) _ _).symm
+
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/ProbePointMasses.lean

@@ -1,208 +1,208 @@
-import OAI.Combinatorics.HadwigerCounterexample.OffsetEnergy
-
-namespace OAI
-
-/-! # Probe Point Masses -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open scoped BigOperators
-open Matrix Module Submodule LinearMap Finset Function
-variable {p : Shape} {n N : ℕ} {q t : Place p→ℕ}
-
-def initCap (p : Shape) {n} (N : ℕ) (m : Mixer p n) (ε : ℝ) :=
-  ∀ a : Pin p n N,pr (pairW (raw m N) (raw m N)) a.agree ≤ fee N ε (planRank a.sp)
-
-def bySide (p : Shape) {n N} (w : Wgt (UnitType p n N))
-    (m : Mixer p n) (c : ℝ) :=
-  ∀ i x, mapW w (fun y => onSide y i) x ≤ c*raw m N x
-
-theorem side_same {A : Type} [Fintype A] (i : Bool) (w : Wgt A) (hw : IsLaw w)
-    (v : Wgt (A × A)) {H : ℝ}
-    (h : ∀ x,mapW v (fun x => onSide x i) x≤H * w x)
-    (P : A×A→Prop) (he : ∀ x y,onSide x i=onSide y i → (P x↔P y)) :
-    pr v P ≤ H * pr (pairW w w) P := by
-  classical
-  let Q := fun x => P (x,x)
-  have hq : P=fun x => Q (onSide x i) := by
-    funext x; exact propext (he x _ (by cases i <;> rfl))
-  rw [hq,←mapW_pr v (fun x => onSide x i) Q]
-  refine (pr_cap h Q).trans_eq ?_
-  have hh : pr (pairW w w) (fun x => Q (onSide x i)) = pr w Q := by
-    cases i
-    · change pr (pairW w w) (fun x => Q x.2)=pr w Q
-      simpa only [true_and, pr_true,hw.total,one_mul] using pairW_pr w w (fun _ => True) Q
-    change pr (pairW w w) (fun x => Q x.1)=pr w Q
-    simpa only [and_true,pr_true,hw.total,mul_one] using pairW_pr w w Q (fun _ => True)
-  rw [hh]
-
-def basisFrom (p : Shape) {n N} (x : UnitType p n N) (i : Bool)
-    {q : Place p→ℕ} (Z : DTuple (p:=p) q N) :=
-  ∀ z,Injective (Z z).mulVec ∧ colSp (Z z) ≤ imageP p x i (flipZ p z)
-
-def ctot (p : Shape) (r : Place p→ℕ) := ∑ i,r i
-abbrev Among (p : Shape) (n : ℕ) (q : Place p→ℕ) :=
-  ∀ z, Mat (Row p n) (Fin (q z))
-def csignal (p : Shape) {n} (i : Bool) {q : Place p → ℕ}
-    (S : Among p n q) : WTuple (p:=p) q n :=
-  fun z => IP p n i * S z
-
-def poke (p : Shape) {n N} {q t : Place p → ℕ}
-    (B : WTuple (p:=p) q n) (C : WTuple (p:=p) t n)
-    (Z : DTuple (p:=p) q N) (A : DTuple (p:=p) t N)
-    (x : UnitType p n N) :=
-  ∀ z, images x (flipZ p z) * B z=Z z ∧ images x z * C z = A z
-
-set_option maxHeartbeats 600000 in
-theorem poke_cap (B : WTuple (p:=p) q n) (C : WTuple (p:=p) t n)
-    (Z : DTuple (p:=p) q N) (A : DTuple (p:=p) t N)
-    (m : Mixer p n) {ε : ℝ} (he : initCap p N m ε)
-    (hB : ∀ z, Injective (B z).mulVec)
-    (hC : ∀ z, Injective (C z).mulVec)
-    (hD : ∀ z, Disjoint (colSp (B z)) (colSp (C (flipZ p z)))) :
-    pr (pairW (raw m N) (raw m N)) (poke p B C Z A) ≤
-      fee N ε (ctot p q+ctot p t) := by
-  classical
-  let μ := raw m N
-  let w := pairW μ μ
-  have hw (x) : 0 ≤ w x := mul_nonneg (raw_nonneg m _) (raw_nonneg m _)
-  by_cases h : 0 < pr w (poke p B C Z A)
-  · obtain ⟨x,hx,_⟩ := exists_of_pr_pos hw h
-    let U : Plan p n := fun z => colSp (B (flipZ p z)) ⊔ colSp (C z)
-    let V := Pin.make U x
-    refine (pr_mono hw (q:=V.agree) fun y hy => ?_).trans ((he V).trans ?_)
-    · intro z v hv
-      change images y z *ᵥ v=images x z *ᵥ v
-      obtain ⟨l,⟨t,rfl⟩,r,⟨u,rfl⟩,rfl⟩ := Submodule.mem_sup.mp
-        (show v∈colSp (B (flipZ p z))⊔colSp (C z) from hv)
-      have h1 := (hx (flipZ p z)).1.trans (hy (flipZ p z)).1.symm
-      simp only [flipZ_flip] at h1
-      simp only [mulVecLin_apply, Matrix.mulVec_add, Matrix.mulVec_mulVec,h1,
-        (hx z).2,(hy z).2]
-    · have hF (z) : dim (U z)=q (flipZ p z)+t z := by
-        have hi := Submodule.finrank_sup_add_finrank_inf_eq (colSp (B (flipZ p z))) (colSp (C z))
-        have hy := hD (flipZ p z)
-        rw [flipZ_flip] at hy
-        rw [hy.eq_bot,finrank_bot,add_zero] at hi
-        exact hi.trans (congrArg₂ (·+·) ((mrk_inj.mp (hB (flipZ p z))).trans (Fintype.card_fin _))
-          ((mrk_inj.mp (hC z)).trans (Fintype.card_fin _)))
-      have ht : planRank V.sp=ctot p q+ctot p t := by
-        unfold planRank ctot
-        change ∑ z,dim (U z)= _
-        simp_rw [hF,Finset.sum_add_distrib]
-        exact congrArg (fun x => x + ∑ z,t z) (Equiv.sum_comp (flipEquiv p) q)
-      rw [ht]
-  exact (not_lt.mp h).trans (bp_pos _).le
-
-def heatRate (p : Shape) (n N : ℕ) (ε : ℝ) (x y : ℕ) :=
-  bp (num (Row p n)* x+ 2*p.h*y)*fee N ε (x+y)
-
-instance amongFintype (p : Shape) (n : ℕ) (r : Place p→ℕ) : Fintype (Among p n r) := by
-  classical exact inferInstanceAs (Fintype (Among p n r))
-
-private theorem format_size :
-    num (Among p n q × (Bool → DTuple (p:=p) t p.h)) =
-      bp (num (Row p n)*ctot p q+2*p.h*ctot p t) := by
-  classical
-  unfold num
-  rw [card_space,dim,Module.finrank_prod, Nat.cast_add]
-  have he : finrank F (Among p n q)=Fintype.card (Row p n)*ctot p q := by
-    unfold Among
-    rw [finrank_pi_fintype]
-    unfold ctot; rw [Finset.mul_sum]
-    refine Finset.sum_congr rfl fun i _ => (dim_mat ..).trans (by rw [Fintype.card_fin])
-  have hf :
-      finrank F (Bool → DTuple (p:=p) t p.h)=2*p.h*ctot p t := by
-    rw [finrank_pi_fintype,Fintype.sum_bool]
-    change dim (DTuple ..)+dim (DTuple ..)=_
-    rw [tuple_dim]
-    unfold ctot; ring
-  rw [he,hf]
-  push_cast; rfl
-
-set_option maxHeartbeats 800000 in
-theorem heat_rate (i : Bool) (S : Party) (hi : S i=1)
-    (A : DTuple (p:=p) t N)
-    (B : DTuple (p:=p) t N) (Z : DTuple (p:=p) q N)
-    (m : Mixer p n) {ε : ℝ} (he : initCap p N m ε) :
-    pr (pairW (raw m N) (raw m N)) (fun x =>
-      basisFrom p x i Z ∧ glimpse p x i A ∧ thermal p x S A=B)
-      ≤ heatRate p n N ε (ctot p q) (ctot p t) := by
-  classical
-  let M := Among p n q × (Bool → DTuple (p:=p) t p.h)
-  let P (v : M) (x : UnitType p n N) :=
-    let X := csignal p i v.1
-    let Y := hfused p n _ v.2
-    (∀ z, Injective (X z).mulVec ∧ Injective (Y z).mulVec) ∧ poke p X Y Z B x
-  let w := pairW (raw m N) (raw m N)
-  have hw x : 0 ≤ w x := mul_nonneg (raw_nonneg m _) (raw_nonneg m _)
-  have h : ∀ x : UnitType p n N,basisFrom p x i Z ∧ glimpse p x i A ∧ thermal p x S A=B →
-      ∃ v, P v x := by
-    rintro x ⟨hF,hT,hU⟩
-    choose A' hA using fun z => pull_cols (fpAt p (onSide x i) (flipZ p z)) (Z z) (hF z).2
-    let C := sparks p x S A
-    let Y := hfused p n _ C
-    let X := csignal p i A'
-    have hh z : images x (flipZ p z)*X z=Z z := by
-      unfold X csignal
-      rw [← Matrix.mul_assoc, images_ip]
-      exact hA z
-    refine ⟨(A',C),fun z => ⟨?_,hotfused x S A i hi hT z⟩, fun z => ?_⟩
-    · have hg := (hF z).1
-      rw [← hh z] at hg
-      intro p' q he
-      apply hg
-      change X z *ᵥ p' = X z*ᵥ q at he
-      rw [← Matrix.mulVec_mulVec,← Matrix.mulVec_mulVec,he]
-    exact ⟨hh z,(fuse_val x S A z).trans (congr_fun hU z)⟩
-  have hg (v : M) :
-      pr w (P v) ≤ fee N ε (ctot p q+ctot p t) := by
-    let X := csignal p i v.1
-    let Y := hfused p n _ v.2
-    by_cases hh : ∀ z, Injective (X z).mulVec ∧ Injective (Y z).mulVec
-    · refine (pr_mono hw (p:=P v) (q:=poke p X Y Z B) fun x h => h.2).trans
-        (poke_cap X Y _ _ m he (fun z => (hh z).1) (fun z => (hh z).2) ?_)
-      intro z
-      exact (channels_disjoint (p:=p) (n:=n)).mono
-        ((col_follow ..).trans (ip_le_primal i)) (fused_support v.2 _)
-    have heq : P v=(fun _ => False) := funext fun x => propext (iff_false_intro (fun h => hh h.1))
-    rw [heq,pr_false]; exact (bp_pos _).le
-  refine ((pr_mono hw h).trans (pr_exists_le hw P)).trans ?_
-  refine (Finset.sum_le_sum fun i _ => hg i).trans_eq ?_
-  simp only [Finset.sum_const,Finset.card_univ,nsmul_eq_mul]
-  change num (Among p n q × _) *_= _
-  rw [format_size]; rfl
-
-theorem heat_one (i : Bool)
-    (A : DTuple (p:=p) t N) (B : DTuple (p:=p) t N)
-    (Z : DTuple (p:=p) q N)
-    {w : Wgt (UnitType p n N)} {H : ℝ} (hH : 0 ≤ H)
-    (m : Mixer p n) {ε : ℝ} (hm : IsLaw (raw m N)) (he : initCap p N m ε)
-    (hw : bySide p w m H) :
-    pr w (fun x => basisFrom p x i Z ∧ glimpse p x i A ∧ thermal p x (unary i) A=B) ≤
-      H*heatRate p n N ε (ctot p q) (ctot p t) := by
-  refine (side_same i _ hm w (hw i) _ ?_).trans
-    (mul_le_mul_of_nonneg_left (heat_rate i (unary i) (by simp [unary]) A B Z m he) hH)
-  intro x y h
-  unfold basisFrom glimpse thermal imageP
-  simp_rw [heat_unary,h]
-
-theorem heat_none (i : Bool) (Z : DTuple (p:=p) q N)
-    {w : Wgt (UnitType p n N)} {H : ℝ} (hH : 0 ≤ H)
-    (m : Mixer p n) {ε : ℝ} (hm : IsLaw (raw m N)) (he : initCap p N m ε)
-    (hw : bySide p w m H) :
-    pr w (fun x => basisFrom p x i Z) ≤ H*heatRate p n N ε (ctot p q) 0 := by
-  classical
-  let t : Place p→ℕ := fun _ => 0
-  let B : DTuple (p:=p) t N := 0
-  have hh := heat_one i B B Z hH m hm he hw
-  have h1 (x : UnitType p n N) : glimpse p x i B := fun z v v' h => Subsingleton.elim v v'
-  have h2 (x : UnitType p n N) : thermal p x (unary i) B=B := Subsingleton.elim _ _
-  simp_rw [h1,h2,and_true] at hh
-  simpa only [ctot,t,Finset.sum_const_zero] using hh
-
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.OffsetEnergy
+
+namespace OAI
+
+/-! # Probe Point Masses -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open scoped BigOperators
+open Matrix Module Submodule LinearMap Finset Function
+variable {p : Shape} {n N : ℕ} {q t : Place p→ℕ}
+
+def initCap (p : Shape) {n} (N : ℕ) (m : Mixer p n) (ε : ℝ) :=
+  ∀ a : Pin p n N,pr (pairW (raw m N) (raw m N)) a.agree ≤ fee N ε (planRank a.sp)
+
+def bySide (p : Shape) {n N} (w : Wgt (UnitType p n N))
+    (m : Mixer p n) (c : ℝ) :=
+  ∀ i x, mapW w (fun y => onSide y i) x ≤ c*raw m N x
+
+theorem side_same {A : Type} [Fintype A] (i : Bool) (w : Wgt A) (hw : IsLaw w)
+    (v : Wgt (A × A)) {H : ℝ}
+    (h : ∀ x,mapW v (fun x => onSide x i) x≤H * w x)
+    (P : A×A→Prop) (he : ∀ x y,onSide x i=onSide y i → (P x↔P y)) :
+    pr v P ≤ H * pr (pairW w w) P := by
+  classical
+  let Q := fun x => P (x,x)
+  have hq : P=fun x => Q (onSide x i) := by
+    funext x; exact propext (he x _ (by cases i <;> rfl))
+  rw [hq,←mapW_pr v (fun x => onSide x i) Q]
+  refine (pr_cap h Q).trans_eq ?_
+  have hh : pr (pairW w w) (fun x => Q (onSide x i)) = pr w Q := by
+    cases i
+    · change pr (pairW w w) (fun x => Q x.2)=pr w Q
+      simpa only [true_and, pr_true,hw.total,one_mul] using pairW_pr w w (fun _ => True) Q
+    change pr (pairW w w) (fun x => Q x.1)=pr w Q
+    simpa only [and_true,pr_true,hw.total,mul_one] using pairW_pr w w Q (fun _ => True)
+  rw [hh]
+
+def basisFrom (p : Shape) {n N} (x : UnitType p n N) (i : Bool)
+    {q : Place p→ℕ} (Z : DTuple (p:=p) q N) :=
+  ∀ z,Injective (Z z).mulVec ∧ colSp (Z z) ≤ imageP p x i (flipZ p z)
+
+def ctot (p : Shape) (r : Place p→ℕ) := ∑ i,r i
+abbrev Among (p : Shape) (n : ℕ) (q : Place p→ℕ) :=
+  ∀ z, Mat (Row p n) (Fin (q z))
+def csignal (p : Shape) {n} (i : Bool) {q : Place p → ℕ}
+    (S : Among p n q) : WTuple (p:=p) q n :=
+  fun z => IP p n i * S z
+
+def poke (p : Shape) {n N} {q t : Place p → ℕ}
+    (B : WTuple (p:=p) q n) (C : WTuple (p:=p) t n)
+    (Z : DTuple (p:=p) q N) (A : DTuple (p:=p) t N)
+    (x : UnitType p n N) :=
+  ∀ z, images x (flipZ p z) * B z=Z z ∧ images x z * C z = A z
+
+set_option maxHeartbeats 600000 in
+theorem poke_cap (B : WTuple (p:=p) q n) (C : WTuple (p:=p) t n)
+    (Z : DTuple (p:=p) q N) (A : DTuple (p:=p) t N)
+    (m : Mixer p n) {ε : ℝ} (he : initCap p N m ε)
+    (hB : ∀ z, Injective (B z).mulVec)
+    (hC : ∀ z, Injective (C z).mulVec)
+    (hD : ∀ z, Disjoint (colSp (B z)) (colSp (C (flipZ p z)))) :
+    pr (pairW (raw m N) (raw m N)) (poke p B C Z A) ≤
+      fee N ε (ctot p q+ctot p t) := by
+  classical
+  let μ := raw m N
+  let w := pairW μ μ
+  have hw (x) : 0 ≤ w x := mul_nonneg (raw_nonneg m _) (raw_nonneg m _)
+  by_cases h : 0 < pr w (poke p B C Z A)
+  · obtain ⟨x,hx,_⟩ := exists_of_pr_pos hw h
+    let U : Plan p n := fun z => colSp (B (flipZ p z)) ⊔ colSp (C z)
+    let V := Pin.make U x
+    refine (pr_mono hw (q:=V.agree) fun y hy => ?_).trans ((he V).trans ?_)
+    · intro z v hv
+      change images y z *ᵥ v=images x z *ᵥ v
+      obtain ⟨l,⟨t,rfl⟩,r,⟨u,rfl⟩,rfl⟩ := Submodule.mem_sup.mp
+        (show v∈colSp (B (flipZ p z))⊔colSp (C z) from hv)
+      have h1 := (hx (flipZ p z)).1.trans (hy (flipZ p z)).1.symm
+      simp only [flipZ_flip] at h1
+      simp only [mulVecLin_apply, Matrix.mulVec_add, Matrix.mulVec_mulVec,h1,
+        (hx z).2,(hy z).2]
+    · have hF (z) : dim (U z)=q (flipZ p z)+t z := by
+        have hi := Submodule.finrank_sup_add_finrank_inf_eq (colSp (B (flipZ p z))) (colSp (C z))
+        have hy := hD (flipZ p z)
+        rw [flipZ_flip] at hy
+        rw [hy.eq_bot,finrank_bot,add_zero] at hi
+        exact hi.trans (congrArg₂ (·+·) ((mrk_inj.mp (hB (flipZ p z))).trans (Fintype.card_fin _))
+          ((mrk_inj.mp (hC z)).trans (Fintype.card_fin _)))
+      have ht : planRank V.sp=ctot p q+ctot p t := by
+        unfold planRank ctot
+        change ∑ z,dim (U z)= _
+        simp_rw [hF,Finset.sum_add_distrib]
+        exact congrArg (fun x => x + ∑ z,t z) (Equiv.sum_comp (flipEquiv p) q)
+      rw [ht]
+  exact (not_lt.mp h).trans (bp_pos _).le
+
+def heatRate (p : Shape) (n N : ℕ) (ε : ℝ) (x y : ℕ) :=
+  bp (num (Row p n)* x+ 2*p.h*y)*fee N ε (x+y)
+
+instance amongFintype (p : Shape) (n : ℕ) (r : Place p→ℕ) : Fintype (Among p n r) := by
+  classical exact inferInstanceAs (Fintype (Among p n r))
+
+private theorem format_size :
+    num (Among p n q × (Bool → DTuple (p:=p) t p.h)) =
+      bp (num (Row p n)*ctot p q+2*p.h*ctot p t) := by
+  classical
+  unfold num
+  rw [card_space,dim,Module.finrank_prod, Nat.cast_add]
+  have he : finrank F (Among p n q)=Fintype.card (Row p n)*ctot p q := by
+    unfold Among
+    rw [finrank_pi_fintype]
+    unfold ctot; rw [Finset.mul_sum]
+    refine Finset.sum_congr rfl fun i _ => (dim_mat ..).trans (by rw [Fintype.card_fin])
+  have hf :
+      finrank F (Bool → DTuple (p:=p) t p.h)=2*p.h*ctot p t := by
+    rw [finrank_pi_fintype,Fintype.sum_bool]
+    change dim (DTuple ..)+dim (DTuple ..)=_
+    rw [tuple_dim]
+    unfold ctot; ring
+  rw [he,hf]
+  push_cast; rfl
+
+set_option maxHeartbeats 800000 in
+theorem heat_rate (i : Bool) (S : Party) (hi : S i=1)
+    (A : DTuple (p:=p) t N)
+    (B : DTuple (p:=p) t N) (Z : DTuple (p:=p) q N)
+    (m : Mixer p n) {ε : ℝ} (he : initCap p N m ε) :
+    pr (pairW (raw m N) (raw m N)) (fun x =>
+      basisFrom p x i Z ∧ glimpse p x i A ∧ thermal p x S A=B)
+      ≤ heatRate p n N ε (ctot p q) (ctot p t) := by
+  classical
+  let M := Among p n q × (Bool → DTuple (p:=p) t p.h)
+  let P (v : M) (x : UnitType p n N) :=
+    let X := csignal p i v.1
+    let Y := hfused p n _ v.2
+    (∀ z, Injective (X z).mulVec ∧ Injective (Y z).mulVec) ∧ poke p X Y Z B x
+  let w := pairW (raw m N) (raw m N)
+  have hw x : 0 ≤ w x := mul_nonneg (raw_nonneg m _) (raw_nonneg m _)
+  have h : ∀ x : UnitType p n N,basisFrom p x i Z ∧ glimpse p x i A ∧ thermal p x S A=B →
+      ∃ v, P v x := by
+    rintro x ⟨hF,hT,hU⟩
+    choose A' hA using fun z => pull_cols (fpAt p (onSide x i) (flipZ p z)) (Z z) (hF z).2
+    let C := sparks p x S A
+    let Y := hfused p n _ C
+    let X := csignal p i A'
+    have hh z : images x (flipZ p z)*X z=Z z := by
+      unfold X csignal
+      rw [← Matrix.mul_assoc, images_ip]
+      exact hA z
+    refine ⟨(A',C),fun z => ⟨?_,hotfused x S A i hi hT z⟩, fun z => ?_⟩
+    · have hg := (hF z).1
+      rw [← hh z] at hg
+      intro p' q he
+      apply hg
+      change X z *ᵥ p' = X z*ᵥ q at he
+      rw [← Matrix.mulVec_mulVec,← Matrix.mulVec_mulVec,he]
+    exact ⟨hh z,(fuse_val x S A z).trans (congr_fun hU z)⟩
+  have hg (v : M) :
+      pr w (P v) ≤ fee N ε (ctot p q+ctot p t) := by
+    let X := csignal p i v.1
+    let Y := hfused p n _ v.2
+    by_cases hh : ∀ z, Injective (X z).mulVec ∧ Injective (Y z).mulVec
+    · refine (pr_mono hw (p:=P v) (q:=poke p X Y Z B) fun x h => h.2).trans
+        (poke_cap X Y _ _ m he (fun z => (hh z).1) (fun z => (hh z).2) ?_)
+      intro z
+      exact (channels_disjoint (p:=p) (n:=n)).mono
+        ((col_follow ..).trans (ip_le_primal i)) (fused_support v.2 _)
+    have heq : P v=(fun _ => False) := funext fun x => propext (iff_false_intro (fun h => hh h.1))
+    rw [heq,pr_false]; exact (bp_pos _).le
+  refine ((pr_mono hw h).trans (pr_exists_le hw P)).trans ?_
+  refine (Finset.sum_le_sum fun i _ => hg i).trans_eq ?_
+  simp only [Finset.sum_const,Finset.card_univ,nsmul_eq_mul]
+  change num (Among p n q × _) *_= _
+  rw [format_size]; rfl
+
+theorem heat_one (i : Bool)
+    (A : DTuple (p:=p) t N) (B : DTuple (p:=p) t N)
+    (Z : DTuple (p:=p) q N)
+    {w : Wgt (UnitType p n N)} {H : ℝ} (hH : 0 ≤ H)
+    (m : Mixer p n) {ε : ℝ} (hm : IsLaw (raw m N)) (he : initCap p N m ε)
+    (hw : bySide p w m H) :
+    pr w (fun x => basisFrom p x i Z ∧ glimpse p x i A ∧ thermal p x (unary i) A=B) ≤
+      H*heatRate p n N ε (ctot p q) (ctot p t) := by
+  refine (side_same i _ hm w (hw i) _ ?_).trans
+    (mul_le_mul_of_nonneg_left (heat_rate i (unary i) (by simp [unary]) A B Z m he) hH)
+  intro x y h
+  unfold basisFrom glimpse thermal imageP
+  simp_rw [heat_unary,h]
+
+theorem heat_none (i : Bool) (Z : DTuple (p:=p) q N)
+    {w : Wgt (UnitType p n N)} {H : ℝ} (hH : 0 ≤ H)
+    (m : Mixer p n) {ε : ℝ} (hm : IsLaw (raw m N)) (he : initCap p N m ε)
+    (hw : bySide p w m H) :
+    pr w (fun x => basisFrom p x i Z) ≤ H*heatRate p n N ε (ctot p q) 0 := by
+  classical
+  let t : Place p→ℕ := fun _ => 0
+  let B : DTuple (p:=p) t N := 0
+  have hh := heat_one i B B Z hH m hm he hw
+  have h1 (x : UnitType p n N) : glimpse p x i B := fun z v v' h => Subsingleton.elim v v'
+  have h2 (x : UnitType p n N) : thermal p x (unary i) B=B := Subsingleton.elim _ _
+  simp_rw [h1,h2,and_true] at hh
+  simpa only [ctot,t,Finset.sum_const_zero] using hh
+
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/ProductCharacterTests.lean

@@ -1,135 +1,135 @@
-import OAI.Combinatorics.HadwigerCounterexample.ConditionedCorrelations
-
-namespace OAI
-
-/-! # Product Character Tests -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Finset Matrix Filter Function
-open scoped BigOperators
-variable {I J A Z D : Type} [Fintype I] [Fintype J] [DecidableEq I] [DecidableEq J]
-variable [Fintype A]
-
-def Pipe (P : A→Z→ ℝ) :=
-  ∃ (f : A→ℝ) (g : Z→ℝ),(∀ i, |f i|≤1) ∧ (∀ i, |g i|≤1) ∧ ∀ x y,P x y=f x*g y
-
-omit [Fintype I] [Fintype A] in
-private theorem pipe_prod (s : Finset I) (P : I → A→Z→ℝ)
-    (h : ∀ i∈s,Pipe (P i)) :
-    Pipe (fun x y => ∏ i∈s,P i x y) := by
-  classical
-  induction s using Finset.induction_on with
-  | empty =>
-    exact ⟨fun _ =>1,fun _=>1,(by simp),(by simp),fun _ _=>by simp⟩
-  | @insert i s hi ih =>
-    obtain ⟨f,g,hf,hg,hH⟩ := h i (by simp)
-    obtain ⟨u,v,hu,hv,hU⟩ := ih (fun j hj => h j (mem_insert_of_mem hj))
-    have he (f g : ℝ) (hf : |f|≤1) (hg : |g|≤1) :
-        |f*g|≤1 := by rw [abs_mul]; exact (mul_le_mul hf hg (abs_nonneg _) zero_le_one).trans_eq
-                                            (by ring)
-    exact ⟨fun x => f x*u x,fun x => g x*v x,(fun x=>he _ _ (hf x) (hu x)),
-      (fun x => he _ _ (hg x) (hv x)),fun x y => by dsimp only at *; rw [prod_insert hi,hH,hU]; ring⟩
-
-structure Stage (I J : Type) where
-  first : J→I
-  nextP : J→I
-  diff k : first k ≠ nextP k
-  once k j : first k=first j → nextP k=nextP j → k=j
-  anti k j : first k=nextP j → nextP k≠first j
-
-variable (s : Stage I J)
-
-set_option maxHeartbeats 600000 in
-theorem far_avg (w : I→Wgt A) (hw : ∀ i,IsLaw (w i)) (F : Wgt (I→A)) (i j : I)
-    (_ : i ≠ j) :
-    let U := prodW w
-    avg U F = avg U (fun x => avg (pairW (w i) (w j)) (fun y => F (update (update x i y.1) j y.2))) := by
-  classical
-  intro U
-  rw [update_avg w j F (hw j),update_avg w i _ (hw i)]
-  simp only [U,pairW_avg]
-private def moveInputs (i j : I) (x : I→A) (p q : A) := update (update x i p) j q
-
-set_option maxHeartbeats 800000 in
-theorem band_res (w : I→ Wgt A) (hw : ∀ i,IsLaw (w i))
-    (f : I→ Wgt A) (hf : ∀ i x,|f i x|≤1)
-    (u : J→ A→ A→ℝ) (hu : ∀ k x y,|u k x y|≤1)
-    (k : J) (η : ℝ)
-    (h : ∀ p q : Wgt A,(∀ i, |p i|≤1)→(∀ i,|q i|≤1) →
-      |avg (pairW (w (s.first k)) (w (s.nextP k))) (fun x =>
-        u k x.1 x.2 * (p x.1*q x.2))|≤η) :
-    |avg (prodW w) (fun x => (∏ j:J,u j (x (s.first j)) (x (s.nextP j)))*prodW f x)|≤η := by
-  classical
-  let i:=s.first k; let j:=s.nextP k
-  have hj : i≠ j := s.diff k
-  let W (x : I→ A) := (∏ j':J,u j' (x (s.first j')) (x (s.nextP j')))*prodW f x
-  have hi (z : I→A) :
-      |avg (pairW (w i) (w j)) (fun x => W (moveInputs i j z x.1 x.2))|≤ η := by
-    let C a b := moveInputs i j z a b
-    let g (v : J⊕I) (a b : A) :=
-      match v with
-      | .inl t => if t=k then 1 else u t (C a b (s.first t)) (C a b (s.nextP t))
-      | .inr t => f t (C a b t)
-    have he a b :
-        W (C a b)=u k a b * ∏ l:J ⊕ I,g l a b := by
-      unfold W prodW; rw [Fintype.prod_sum_type]
-      rw [← mul_prod_erase _ _ (mem_univ k),←mul_prod_erase _
-        (fun t:J=>g (.inl t) a b) (mem_univ k)]
-      have he (t:J) (h : t∈univ.erase k) :
-          g (Sum.inl t) a b=u t (C a b (s.first t)) (C a b (s.nextP t)) :=
-        ite_eq_right (mem_erase.mp h).1
-      rw [Finset.prod_congr rfl (g:=fun t:J => u t (C a b (s.first t)) (C a b (s.nextP t))) he]
-      change (u k (C a b i) (C a b j)*_) *_=_
-      rw [show C a b i=a from (by simp [C,moveInputs,hj]),
-        show C a b j=b from (by simp [C,moveInputs]),show g (.inl k) a b=1 from
-        (by simp [g]),one_mul,mul_assoc]
-    let d := z i
-    have hp : ∀ x:J ⊕ I,Pipe (g x) := by
-      have he (t : I) (h : t ≠ j) (a b : A) : C a b t=C a d t := by
-        unfold C moveInputs; rw [update_of_ne h,update_of_ne h]
-      have hu' (t : I) (h : t ≠ i) (a b : A) : C a b t=C d b t := by
-        unfold C moveInputs
-        by_cases hx : t=j <;> simp [hx,h]
-      have h1 (x:J⊕I) (h : ∀ a b,|g x a b|≤1)
-          (e : (∀ a b,g x a b=g x a d)∨(∀ a b,g x a b=g x d b)) :
-          Pipe (g x) := by
-        rcases e with e|e
-        · exact ⟨fun a=>g x a d,fun _=>1,fun i=>h _ _,(by simp),fun i j=> (e i j).trans
-            (by rw [mul_one])⟩
-        exact ⟨fun _=>1,g x d,(by simp),h d,fun i j=> (e i j).trans (by rw [one_mul])⟩
-      rintro (l|l)
-      · by_cases hh : l=k
-        · subst l; exact h1 (Sum.inl k) (by simp [g]) (Or.inl (by simp [g]))
-        apply h1 (Sum.inl l) (fun a b => by simp only [g,ite_eq_right hh]; exact hu _ _ _)
-        have hh1 :
-            (s.first l≠j∧s.nextP l≠j) ∨(s.first l≠i∧s.nextP l≠i) := by
-          by_contra! ha
-          by_cases hx : s.first l=j
-          · have hy : s.first l≠i := hx ▸ Ne.symm hj
-            exact s.anti l k hx (ha.2 hy)
-          have ht := ha.1 hx
-          have hs : s.first l=i := by_contra (fun h=>hj ((ha.2 h).symm.trans ht))
-          exact hh (s.once l k hs ht)
-        simp only [g,ite_eq_right hh]; rcases hh1 with ⟨h,h'⟩|⟨h,h'⟩
-        · left; intro a b; rw [he _ h,he _ h']
-        right; intro a b; rw [hu' _ h,hu' _ h']
-      apply h1 (Sum.inr l) (fun a b => hf _ _)
-      unfold g
-      by_cases h : l=i
-      · exact Or.inl fun a b => congrArg _ (he _ (h.symm ▸ hj) _ _)
-      exact Or.inr fun a b=> congrArg _ (hu' l h a b)
-    obtain ⟨p,q,hp,hq,ht⟩ := pipe_prod univ g (fun i _ => hp i)
-    have heq (x : A×A) : W (moveInputs i j z x.1 x.2)=u k x.1 x.2*(p x.1*q x.2) := by
-      change W (C _ _)=_
-      rw [he]; exact congrArg (_ * ·) (ht x.1 x.2)
-    simp_rw [heq]
-    exact h p q hp hq
-  change |avg _ W|≤η
-  rw [far_avg w hw W i j hj]
-  exact (abs_avg_le (prodW_law hw).nz).trans ((prodW_law hw).avg_le hi)
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.ConditionedCorrelations
+
+namespace OAI
+
+/-! # Product Character Tests -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Finset Matrix Filter Function
+open scoped BigOperators
+variable {I J A Z D : Type} [Fintype I] [Fintype J] [DecidableEq I] [DecidableEq J]
+variable [Fintype A]
+
+def Pipe (P : A→Z→ ℝ) :=
+  ∃ (f : A→ℝ) (g : Z→ℝ),(∀ i, |f i|≤1) ∧ (∀ i, |g i|≤1) ∧ ∀ x y,P x y=f x*g y
+
+omit [Fintype I] [Fintype A] in
+private theorem pipe_prod (s : Finset I) (P : I → A→Z→ℝ)
+    (h : ∀ i∈s,Pipe (P i)) :
+    Pipe (fun x y => ∏ i∈s,P i x y) := by
+  classical
+  induction s using Finset.induction_on with
+  | empty =>
+    exact ⟨fun _ =>1,fun _=>1,(by simp),(by simp),fun _ _=>by simp⟩
+  | @insert i s hi ih =>
+    obtain ⟨f,g,hf,hg,hH⟩ := h i (by simp)
+    obtain ⟨u,v,hu,hv,hU⟩ := ih (fun j hj => h j (mem_insert_of_mem hj))
+    have he (f g : ℝ) (hf : |f|≤1) (hg : |g|≤1) :
+        |f*g|≤1 := by rw [abs_mul]; exact (mul_le_mul hf hg (abs_nonneg _) zero_le_one).trans_eq
+                                            (by ring)
+    exact ⟨fun x => f x*u x,fun x => g x*v x,(fun x=>he _ _ (hf x) (hu x)),
+      (fun x => he _ _ (hg x) (hv x)),fun x y => by dsimp only at *; rw [prod_insert hi,hH,hU]; ring⟩
+
+structure Stage (I J : Type) where
+  first : J→I
+  nextP : J→I
+  diff k : first k ≠ nextP k
+  once k j : first k=first j → nextP k=nextP j → k=j
+  anti k j : first k=nextP j → nextP k≠first j
+
+variable (s : Stage I J)
+
+set_option maxHeartbeats 600000 in
+theorem far_avg (w : I→Wgt A) (hw : ∀ i,IsLaw (w i)) (F : Wgt (I→A)) (i j : I)
+    (_ : i ≠ j) :
+    let U := prodW w
+    avg U F = avg U (fun x => avg (pairW (w i) (w j)) (fun y => F (update (update x i y.1) j y.2))) := by
+  classical
+  intro U
+  rw [update_avg w j F (hw j),update_avg w i _ (hw i)]
+  simp only [U,pairW_avg]
+private def moveInputs (i j : I) (x : I→A) (p q : A) := update (update x i p) j q
+
+set_option maxHeartbeats 800000 in
+theorem band_res (w : I→ Wgt A) (hw : ∀ i,IsLaw (w i))
+    (f : I→ Wgt A) (hf : ∀ i x,|f i x|≤1)
+    (u : J→ A→ A→ℝ) (hu : ∀ k x y,|u k x y|≤1)
+    (k : J) (η : ℝ)
+    (h : ∀ p q : Wgt A,(∀ i, |p i|≤1)→(∀ i,|q i|≤1) →
+      |avg (pairW (w (s.first k)) (w (s.nextP k))) (fun x =>
+        u k x.1 x.2 * (p x.1*q x.2))|≤η) :
+    |avg (prodW w) (fun x => (∏ j:J,u j (x (s.first j)) (x (s.nextP j)))*prodW f x)|≤η := by
+  classical
+  let i:=s.first k; let j:=s.nextP k
+  have hj : i≠ j := s.diff k
+  let W (x : I→ A) := (∏ j':J,u j' (x (s.first j')) (x (s.nextP j')))*prodW f x
+  have hi (z : I→A) :
+      |avg (pairW (w i) (w j)) (fun x => W (moveInputs i j z x.1 x.2))|≤ η := by
+    let C a b := moveInputs i j z a b
+    let g (v : J⊕I) (a b : A) :=
+      match v with
+      | .inl t => if t=k then 1 else u t (C a b (s.first t)) (C a b (s.nextP t))
+      | .inr t => f t (C a b t)
+    have he a b :
+        W (C a b)=u k a b * ∏ l:J ⊕ I,g l a b := by
+      unfold W prodW; rw [Fintype.prod_sum_type]
+      rw [← mul_prod_erase _ _ (mem_univ k),←mul_prod_erase _
+        (fun t:J=>g (.inl t) a b) (mem_univ k)]
+      have he (t:J) (h : t∈univ.erase k) :
+          g (Sum.inl t) a b=u t (C a b (s.first t)) (C a b (s.nextP t)) :=
+        ite_eq_right (mem_erase.mp h).1
+      rw [Finset.prod_congr rfl (g:=fun t:J => u t (C a b (s.first t)) (C a b (s.nextP t))) he]
+      change (u k (C a b i) (C a b j)*_) *_=_
+      rw [show C a b i=a from (by simp [C,moveInputs,hj]),
+        show C a b j=b from (by simp [C,moveInputs]),show g (.inl k) a b=1 from
+        (by simp [g]),one_mul,mul_assoc]
+    let d := z i
+    have hp : ∀ x:J ⊕ I,Pipe (g x) := by
+      have he (t : I) (h : t ≠ j) (a b : A) : C a b t=C a d t := by
+        unfold C moveInputs; rw [update_of_ne h,update_of_ne h]
+      have hu' (t : I) (h : t ≠ i) (a b : A) : C a b t=C d b t := by
+        unfold C moveInputs
+        by_cases hx : t=j <;> simp [hx,h]
+      have h1 (x:J⊕I) (h : ∀ a b,|g x a b|≤1)
+          (e : (∀ a b,g x a b=g x a d)∨(∀ a b,g x a b=g x d b)) :
+          Pipe (g x) := by
+        rcases e with e|e
+        · exact ⟨fun a=>g x a d,fun _=>1,fun i=>h _ _,(by simp),fun i j=> (e i j).trans
+            (by rw [mul_one])⟩
+        exact ⟨fun _=>1,g x d,(by simp),h d,fun i j=> (e i j).trans (by rw [one_mul])⟩
+      rintro (l|l)
+      · by_cases hh : l=k
+        · subst l; exact h1 (Sum.inl k) (by simp [g]) (Or.inl (by simp [g]))
+        apply h1 (Sum.inl l) (fun a b => by simp only [g,ite_eq_right hh]; exact hu _ _ _)
+        have hh1 :
+            (s.first l≠j∧s.nextP l≠j) ∨(s.first l≠i∧s.nextP l≠i) := by
+          by_contra! ha
+          by_cases hx : s.first l=j
+          · have hy : s.first l≠i := hx ▸ Ne.symm hj
+            exact s.anti l k hx (ha.2 hy)
+          have ht := ha.1 hx
+          have hs : s.first l=i := by_contra (fun h=>hj ((ha.2 h).symm.trans ht))
+          exact hh (s.once l k hs ht)
+        simp only [g,ite_eq_right hh]; rcases hh1 with ⟨h,h'⟩|⟨h,h'⟩
+        · left; intro a b; rw [he _ h,he _ h']
+        right; intro a b; rw [hu' _ h,hu' _ h']
+      apply h1 (Sum.inr l) (fun a b => hf _ _)
+      unfold g
+      by_cases h : l=i
+      · exact Or.inl fun a b => congrArg _ (he _ (h.symm ▸ hj) _ _)
+      exact Or.inr fun a b=> congrArg _ (hu' l h a b)
+    obtain ⟨p,q,hp,hq,ht⟩ := pipe_prod univ g (fun i _ => hp i)
+    have heq (x : A×A) : W (moveInputs i j z x.1 x.2)=u k x.1 x.2*(p x.1*q x.2) := by
+      change W (C _ _)=_
+      rw [he]; exact congrArg (_ * ·) (ht x.1 x.2)
+    simp_rw [heq]
+    exact h p q hp hq
+  change |avg _ W|≤η
+  rw [far_avg w hw W i j hj]
+  exact (abs_avg_le (prodW_law hw).nz).trans ((prodW_law hw).avg_le hi)
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/ProductComparisonScales.lean

@@ -1,130 +1,130 @@
-import OAI.Combinatorics.HadwigerCounterexample.RecursiveComparisonErrors
-
-namespace OAI
-
-/-! # Product Comparison Scales -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Matrix Module Function Finset Filter
-open scoped BigOperators
-variable {p : Shape} {n N M : ℕ} {I : Type} [Fintype I] [DecidableEq I]
-namespace Template
-variable (v : Template p I)
-
-def play (v : Template p I) (M : ℕ) (C b ε : ℝ) :=
-  ∃ (r : ℕ) (c : ℝ),0<c ∧ ∀ᶠ n : ℕ in atTop, let N:=M*n; ∀ (q : I→F)
-    (U : Wgt (Keys (p:=p) v.t N)), (∀ i, |U i|≤ b) →
-    ∃ T,design v T b r∧ shadowed v q (U-T) ε ∧ engaged v q (U-T) n C (bp (-c*n)) ε
-
-theorem play_empty (v : Template p I) (M : ℕ) (C b ε : ℝ) [IsEmpty I]
-    (hε : 0≤ε) :
-    play v M C b ε := by
-  classical
-  refine ⟨1,1,zero_lt_one,.of_forall (fun n => ?_)⟩
-  intro N q U hU
-  let i : Keys (p:=p) v.t N := 0
-  refine ⟨U, ⟨fun _ => ⟨U i,fun _ _=> True⟩,?_,fun _=>hU _⟩,fun f h=>?_,
-    fun m hN w hw s x h hh =>?_⟩
-  · funext x
-    simp only [mural,Paint.cost,prodW,ind_true,prod_const_one,mul_one,sum_const,
-      card_univ,Fintype.card_fin,one_smul]
-    exact congrArg U (Subsingleton.elim x i)
-  · simp only [board,sub_self,curtain,Pi.zero_apply,mul_zero,zero_mul,avg_zero,abs_zero]
-    exact hε
-  · have ht o : ¬ exceeds v q (U-U) s m x ε o := by
-      rintro ⟨f,_,hh⟩
-      simp only [scene,protean,curtain,sub_self,Pi.zero_apply,mul_zero,zero_mul,avg_zero,
-        abs_zero] at hh
-      exact (not_lt_of_ge hε) hh
-    rw [show exceeds _ _ _ _ _ _ _=(fun _=>False) from funext fun i=>propext ⟨ht i,False.elim⟩,
-      pr_false]; exact (bp_pos _).le
-
-set_option maxHeartbeats 1200000 in
-theorem play_step (v : Template p I) (j : I) (M : ℕ) (hM : 1≤ M) (C b ε : ℝ)
-    (hb : 0≤b) (hε : 0<ε)
-    (h : play (v.beyond j) M C b (ε/2)) :
-    play v M C b ε := by
-  classical
-  let u:= ε/2; let L:=1+2*b; have hu : 0<u := by positivity
-  have hL : 0<L := by positivity
-  obtain ⟨δ,hδ,hh⟩ := shade_calendar v j M hM C (u/L) (by positivity)
-  let d := min δ (u/L)
-  have hd : 0<d := lt_min hδ (by positivity)
-  obtain ⟨s,hs⟩ := shattered v j b L d hL hb (by unfold L; linarith) hd
-  obtain ⟨r,c,hc,h⟩ := h
-  let t := min (1/16:ℝ) c
-  have ht : 0<t := lt_min (by norm_num) hc
-  refine ⟨s*r,t/2,by linarith,?_⟩
-  filter_upwards [hh,h,pay_nat (a:=t) (b:=t/2) ((s:ℝ)+1) (by linarith)]
-    with n hn h ha N q U hU
-  obtain ⟨l,hl,a,B,hb',hs,hQ,hW⟩ := hs N q U hU
-  let V:= patched v j a B
-  let W := U-V
-  let R i := curtain v q W i/L
-  let T:=v.beyond j
-  let Q:= v.boundTail j q
-  choose g h1 h2 h3 using fun i=> h Q (B i) (hb' i)
-  let D := patched v j a g
-  have hT : shadowed v q W u := by
-    have he := chair_board v j q W L d hL hQ
-    have hm : d*L ≤ u := (le_div_iff₀ hL).mp (min_le_right ..)
-    exact fun i hi => (he i hi).trans hm
-  have hx : engaged v q W n C (bp (-(1/16:ℝ)*n)) u := by
-    intro m hN w hw s x hx hz
-    have he : chairCut v j R δ :=
-      fun i hi k hk=> (hQ i hi k hk).trans (min_le_left ..)
-    have hg (x) : |propel v s m x|≤1 := by
-      unfold propel; rw [abs_of_nonneg (ind_nonneg _)]
-      exact ind_le_one _
-    obtain ⟨hw,hv,h',hm'⟩ := hw
-    have h4 := hn q R (propel v s m) x hs he hW hg hx hz m hN w hw hv h' hm'
-    refine (pr_mono hw.nz (fun i hh => ?_)).trans h4
-    obtain ⟨f,hf,hg⟩ := hh
-    refine ⟨f,hf,?_⟩
-    unfold R
-    rw [put_back v q W L,abs_div,abs_of_pos hL]
-    exact div_lt_div_of_pos_right hg hL
-  have hg := gild_play v j q n N l a B g U C u _ _ hT hx h2 h3
-  have heq : u+u=ε := by unfold u; ring
-  dsimp only at hg
-  rw [heq] at hg
-  refine ⟨D,design_mono v D b _ (s*r) hb (Nat.mul_le_mul_right r hl)
-    (design_patch v j l r a g b h1),hg.1,?_⟩
-  intro m hN w hw s' x hx hz
-  apply (hg.2 m hN w hw s' x hx hz).trans
-  apply le_trans ?_ ha
-  let z := bp (-t*n)
-  have h1 : bp (-c*n)≤ z := bp_le (by gcongr; exact min_le_right ..)
-  have h2 : bp (-(1/16:ℝ)*n)≤ z := bp_le (by gcongr; exact min_le_left ..)
-  exact (add_le_add h2 (mul_le_mul (by exact_mod_cast hl) h1 (bp_pos _).le
-    (Nat.cast_nonneg s))).trans_eq (by ring)
-
-theorem plays_calendar (p : Shape) (M : ℕ) (hM : 1≤M) (C b : ℝ) (hb : 0 ≤ b)
-    (r : ℕ) :
-    ∀ (I : Type) [Fintype I] [DecidableEq I],Fintype.card I≤r →
-      ∀ v : Template p I,∀ ε : ℝ,0< ε→play v M C b ε := by
-  classical
-  induction r with
-  | zero =>
-    intro I inst h hi v ε he
-    have : IsEmpty I := Fintype.card_eq_zero_iff.mp (Nat.eq_zero_of_le_zero hi)
-    exact play_empty v M C b ε he.le
-  | succ r ih =>
-    intro I _ _ h v ε he
-    cases isEmpty_or_nonempty I
-    next => exact play_empty v M C b ε he.le
-    next hi =>
-      obtain ⟨i⟩:=hi
-      apply play_step v i M hM C b ε hb he
-      refine ih _ ?_ _ _ (half_pos he)
-      have hh : Fintype.card (Aside i)+1=Fintype.card I := by
-        have hg := Fintype.card_congr (Equiv.optionSubtypeNe i)
-        simpa only [Aside,Fintype.card_option] using hg
-      omega
-end Template
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.RecursiveComparisonErrors
+
+namespace OAI
+
+/-! # Product Comparison Scales -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Matrix Module Function Finset Filter
+open scoped BigOperators
+variable {p : Shape} {n N M : ℕ} {I : Type} [Fintype I] [DecidableEq I]
+namespace Template
+variable (v : Template p I)
+
+def play (v : Template p I) (M : ℕ) (C b ε : ℝ) :=
+  ∃ (r : ℕ) (c : ℝ),0<c ∧ ∀ᶠ n : ℕ in atTop, let N:=M*n; ∀ (q : I→F)
+    (U : Wgt (Keys (p:=p) v.t N)), (∀ i, |U i|≤ b) →
+    ∃ T,design v T b r∧ shadowed v q (U-T) ε ∧ engaged v q (U-T) n C (bp (-c*n)) ε
+
+theorem play_empty (v : Template p I) (M : ℕ) (C b ε : ℝ) [IsEmpty I]
+    (hε : 0≤ε) :
+    play v M C b ε := by
+  classical
+  refine ⟨1,1,zero_lt_one,.of_forall (fun n => ?_)⟩
+  intro N q U hU
+  let i : Keys (p:=p) v.t N := 0
+  refine ⟨U, ⟨fun _ => ⟨U i,fun _ _=> True⟩,?_,fun _=>hU _⟩,fun f h=>?_,
+    fun m hN w hw s x h hh =>?_⟩
+  · funext x
+    simp only [mural,Paint.cost,prodW,ind_true,prod_const_one,mul_one,sum_const,
+      card_univ,Fintype.card_fin,one_smul]
+    exact congrArg U (Subsingleton.elim x i)
+  · simp only [board,sub_self,curtain,Pi.zero_apply,mul_zero,zero_mul,avg_zero,abs_zero]
+    exact hε
+  · have ht o : ¬ exceeds v q (U-U) s m x ε o := by
+      rintro ⟨f,_,hh⟩
+      simp only [scene,protean,curtain,sub_self,Pi.zero_apply,mul_zero,zero_mul,avg_zero,
+        abs_zero] at hh
+      exact (not_lt_of_ge hε) hh
+    rw [show exceeds _ _ _ _ _ _ _=(fun _=>False) from funext fun i=>propext ⟨ht i,False.elim⟩,
+      pr_false]; exact (bp_pos _).le
+
+set_option maxHeartbeats 1200000 in
+theorem play_step (v : Template p I) (j : I) (M : ℕ) (hM : 1≤ M) (C b ε : ℝ)
+    (hb : 0≤b) (hε : 0<ε)
+    (h : play (v.beyond j) M C b (ε/2)) :
+    play v M C b ε := by
+  classical
+  let u:= ε/2; let L:=1+2*b; have hu : 0<u := by positivity
+  have hL : 0<L := by positivity
+  obtain ⟨δ,hδ,hh⟩ := shade_calendar v j M hM C (u/L) (by positivity)
+  let d := min δ (u/L)
+  have hd : 0<d := lt_min hδ (by positivity)
+  obtain ⟨s,hs⟩ := shattered v j b L d hL hb (by unfold L; linarith) hd
+  obtain ⟨r,c,hc,h⟩ := h
+  let t := min (1/16:ℝ) c
+  have ht : 0<t := lt_min (by norm_num) hc
+  refine ⟨s*r,t/2,by linarith,?_⟩
+  filter_upwards [hh,h,pay_nat (a:=t) (b:=t/2) ((s:ℝ)+1) (by linarith)]
+    with n hn h ha N q U hU
+  obtain ⟨l,hl,a,B,hb',hs,hQ,hW⟩ := hs N q U hU
+  let V:= patched v j a B
+  let W := U-V
+  let R i := curtain v q W i/L
+  let T:=v.beyond j
+  let Q:= v.boundTail j q
+  choose g h1 h2 h3 using fun i=> h Q (B i) (hb' i)
+  let D := patched v j a g
+  have hT : shadowed v q W u := by
+    have he := chair_board v j q W L d hL hQ
+    have hm : d*L ≤ u := (le_div_iff₀ hL).mp (min_le_right ..)
+    exact fun i hi => (he i hi).trans hm
+  have hx : engaged v q W n C (bp (-(1/16:ℝ)*n)) u := by
+    intro m hN w hw s x hx hz
+    have he : chairCut v j R δ :=
+      fun i hi k hk=> (hQ i hi k hk).trans (min_le_left ..)
+    have hg (x) : |propel v s m x|≤1 := by
+      unfold propel; rw [abs_of_nonneg (ind_nonneg _)]
+      exact ind_le_one _
+    obtain ⟨hw,hv,h',hm'⟩ := hw
+    have h4 := hn q R (propel v s m) x hs he hW hg hx hz m hN w hw hv h' hm'
+    refine (pr_mono hw.nz (fun i hh => ?_)).trans h4
+    obtain ⟨f,hf,hg⟩ := hh
+    refine ⟨f,hf,?_⟩
+    unfold R
+    rw [put_back v q W L,abs_div,abs_of_pos hL]
+    exact div_lt_div_of_pos_right hg hL
+  have hg := gild_play v j q n N l a B g U C u _ _ hT hx h2 h3
+  have heq : u+u=ε := by unfold u; ring
+  dsimp only at hg
+  rw [heq] at hg
+  refine ⟨D,design_mono v D b _ (s*r) hb (Nat.mul_le_mul_right r hl)
+    (design_patch v j l r a g b h1),hg.1,?_⟩
+  intro m hN w hw s' x hx hz
+  apply (hg.2 m hN w hw s' x hx hz).trans
+  apply le_trans ?_ ha
+  let z := bp (-t*n)
+  have h1 : bp (-c*n)≤ z := bp_le (by gcongr; exact min_le_right ..)
+  have h2 : bp (-(1/16:ℝ)*n)≤ z := bp_le (by gcongr; exact min_le_left ..)
+  exact (add_le_add h2 (mul_le_mul (by exact_mod_cast hl) h1 (bp_pos _).le
+    (Nat.cast_nonneg s))).trans_eq (by ring)
+
+theorem plays_calendar (p : Shape) (M : ℕ) (hM : 1≤M) (C b : ℝ) (hb : 0 ≤ b)
+    (r : ℕ) :
+    ∀ (I : Type) [Fintype I] [DecidableEq I],Fintype.card I≤r →
+      ∀ v : Template p I,∀ ε : ℝ,0< ε→play v M C b ε := by
+  classical
+  induction r with
+  | zero =>
+    intro I inst h hi v ε he
+    have : IsEmpty I := Fintype.card_eq_zero_iff.mp (Nat.eq_zero_of_le_zero hi)
+    exact play_empty v M C b ε he.le
+  | succ r ih =>
+    intro I _ _ h v ε he
+    cases isEmpty_or_nonempty I
+    next => exact play_empty v M C b ε he.le
+    next hi =>
+      obtain ⟨i⟩:=hi
+      apply play_step v i M hM C b ε hb he
+      refine ih _ ?_ _ _ (half_pos he)
+      have hh : Fintype.card (Aside i)+1=Fintype.card I := by
+        have hg := Fintype.card_congr (Equiv.optionSubtypeNe i)
+        simpa only [Aside,Fintype.card_option] using hg
+      omega
+end Template
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/ProductCoordinateReplacement.lean

@@ -1,58 +1,58 @@
-import OAI.Combinatorics.HadwigerCounterexample.PairedRankBounds
-
-namespace OAI
-
-/-! # Product Coordinate Replacement -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Finset Matrix Function
-open scoped BigOperators
-variable {I J K : Type} {A : Type} [Fintype I] [DecidableEq I] [Fintype A]
-
-set_option maxHeartbeats 600000 in
-theorem update_avg (p : I→ Wgt A) (i : I) (f : Wgt (I→A)) (hp : IsLaw (p i)) :
-    avg (prodW p) f = avg (prodW p) (fun x => avg (p i) (fun y => f (update x i y))) := by
-  classical
-
-  let e : ((I→A)×A)≃ ((I→A)×A) := {
-    toFun x := (update x.1 i x.2,x.1 i)
-    invFun x := (update x.1 i x.2,x.1 i)
-    left_inv x := by simp
-    right_inv x := by simp }
-  let μ := pairW (prodW p) (p i)
-  have he (x : (I→A)×A) : μ (e x)=μ x := by
-    unfold μ pairW prodW
-    let s := Finset.univ.erase i
-    rw [←Finset.mul_prod_erase _ _ (mem_univ i),←Finset.mul_prod_erase _
-      (fun i => p i (x.1 i)) (mem_univ i)]
-    have h :
-        ∏ j∈s,p j (update x.1 i x.2 j)=∏ j∈s,p j (x.1 j) := by
-      refine prod_congr rfl fun j hj => ?_
-      rw [update_of_ne ((mem_erase.mp hj).1)]
-    change p i _ * (∏ j∈s,p j (update x.1 i x.2 j))*p i (x.1 i)=_
-    rw [h]
-    change p i (Function.update x.1 i (x.2) i) * _ * _=_
-    rw [Function.update_self]; ac_rfl
-  have ht := avg_bij e μ (fun x => f x.1)
-  simp_rw [he] at ht
-  unfold μ at ht; simp only [pairW_avg,hp.avg_const] at ht
-  exact ht.symm
-
-theorem update2_avg (p q : I→Wgt A) (i : I) (f : Wgt ((I→A)×(I→A))) (hp : IsLaw (p i))
-    (hq : IsLaw (q i)) :
-    let u := pairW (prodW p) (prodW q)
-    avg u f = avg u (fun x => avg (pairW (p i) (q i))
-      (fun y => f (update x.1 i y.1,update x.2 i y.2))) := by
-  intro u
-  simp only [u,pairW_avg]
-  conv_lhs => rw [update_avg p i _ hp]
-  apply avg_congr; intro x _
-
-  conv_rhs => rw [avg_avg]
-  exact avg_congr (fun _ _ => update_avg q i _ hq)
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.PairedRankBounds
+
+namespace OAI
+
+/-! # Product Coordinate Replacement -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Finset Matrix Function
+open scoped BigOperators
+variable {I J K : Type} {A : Type} [Fintype I] [DecidableEq I] [Fintype A]
+
+set_option maxHeartbeats 600000 in
+theorem update_avg (p : I→ Wgt A) (i : I) (f : Wgt (I→A)) (hp : IsLaw (p i)) :
+    avg (prodW p) f = avg (prodW p) (fun x => avg (p i) (fun y => f (update x i y))) := by
+  classical
+
+  let e : ((I→A)×A)≃ ((I→A)×A) := {
+    toFun x := (update x.1 i x.2,x.1 i)
+    invFun x := (update x.1 i x.2,x.1 i)
+    left_inv x := by simp
+    right_inv x := by simp }
+  let μ := pairW (prodW p) (p i)
+  have he (x : (I→A)×A) : μ (e x)=μ x := by
+    unfold μ pairW prodW
+    let s := Finset.univ.erase i
+    rw [←Finset.mul_prod_erase _ _ (mem_univ i),←Finset.mul_prod_erase _
+      (fun i => p i (x.1 i)) (mem_univ i)]
+    have h :
+        ∏ j∈s,p j (update x.1 i x.2 j)=∏ j∈s,p j (x.1 j) := by
+      refine prod_congr rfl fun j hj => ?_
+      rw [update_of_ne ((mem_erase.mp hj).1)]
+    change p i _ * (∏ j∈s,p j (update x.1 i x.2 j))*p i (x.1 i)=_
+    rw [h]
+    change p i (Function.update x.1 i (x.2) i) * _ * _=_
+    rw [Function.update_self]; ac_rfl
+  have ht := avg_bij e μ (fun x => f x.1)
+  simp_rw [he] at ht
+  unfold μ at ht; simp only [pairW_avg,hp.avg_const] at ht
+  exact ht.symm
+
+theorem update2_avg (p q : I→Wgt A) (i : I) (f : Wgt ((I→A)×(I→A))) (hp : IsLaw (p i))
+    (hq : IsLaw (q i)) :
+    let u := pairW (prodW p) (prodW q)
+    avg u f = avg u (fun x => avg (pairW (p i) (q i))
+      (fun y => f (update x.1 i y.1,update x.2 i y.2))) := by
+  intro u
+  simp only [u,pairW_avg]
+  conv_lhs => rw [update_avg p i _ hp]
+  apply avg_congr; intro x _
+
+  conv_rhs => rw [avg_avg]
+  exact avg_congr (fun _ _ => update_avg q i _ hq)
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/ProductLaws.lean

@@ -1,119 +1,119 @@
-import OAI.Combinatorics.HadwigerCounterexample.FiniteLaws
-import Mathlib.Data.Fintype.Pi
-import Mathlib.Algebra.BigOperators.GroupWithZero.Finset
-
-namespace OAI
-
-/-! # Product Laws -/
-
-noncomputable section
-open scoped BigOperators
-namespace HadwigerCounterexample
-
-theorem ind_all {ι : Type*} [Fintype ι] (p : ι → Prop) :
-    ind (∀ i, p i) = ∏ i, ind (p i) := by
-  classical
-  simp [ind, Fintype.prod_ite_zero]
-
-variable {ι κ α : Type*}
-variable {β : ι → Type*}
-
-def prodW [Fintype ι] (w : ∀ i, Wgt (β i)) : Wgt (∀ i, β i) := fun x => ∏ i, w i (x i)
-
-section
-variable [Fintype ι] [DecidableEq ι] [∀ i, Fintype (β i)]
-
-theorem prodW_tot (w : ∀ i, Wgt (β i)) : tot (prodW w) = ∏ i, tot (w i) :=
-  (Fintype.prod_sum w).symm
-
-theorem prodW_avg (w f : ∀ i, Wgt (β i)) :
-    avg (prodW w) (prodW f) = ∏ i, avg (w i) (f i) := by
-  simp only [avg, prodW]
-  rw [Fintype.prod_sum]
-  simp only [Finset.prod_mul_distrib]
-
-theorem prodW_pr (w : ∀ i, Wgt (β i)) (p : ∀ i, β i → Prop) :
-    pr (prodW w) (fun x => ∀ i, p i (x i)) = ∏ i, pr (w i) (p i) := by
-  simp_rw [pr, ind_all]
-  exact prodW_avg w (fun i x => ind (p i x))
-
-omit [DecidableEq ι] [∀ i, Fintype (β i)] in
-theorem prodW_nonneg {w : ∀ i, Wgt (β i)} (h : ∀ i x, 0 ≤ w i x) (x) : 0 ≤ prodW w x :=
-  Finset.prod_nonneg (fun i _ => h i _)
-
-theorem prodW_law {w : ∀ i, Wgt (β i)} (hw : ∀ i, IsLaw (w i)) : IsLaw (prodW w) := by
-  refine ⟨prodW_nonneg (fun i => (hw i).nz), ?_⟩
-  rw [prodW_tot]
-  simp_rw [(hw _).total]
-  simp
-
-end
-
-section
-variable [Fintype ι] [Fintype κ] [Fintype α] [DecidableEq κ]
-/-- Observe distinct coordinates of a (constant-type) product law. -/
-theorem prodW_pr_inj {e : ι → κ} (he : Function.Injective e)
-    {w : κ → Wgt α} (hw : ∀ k, IsLaw (w k)) (p : ι → α → Prop) :
-    pr (prodW (β:=fun _ => α) w) (fun x => ∀ i, p i (x (e i))) =
-      ∏ i, pr (w (e i)) (p i) := by
-  classical
-  let P (k : κ) (x : α) := ∀ i, e i = k → p i x
-  have h (x : κ → α) : (∀ i, p i (x (e i))) ↔ ∀ k, P k (x k) :=
-    ⟨fun h k i hi => hi ▸ h i, fun h i => h (e i) i rfl⟩
-  simp_rw [h]
-  rw [prodW_pr _ P]
-  let f (k : κ) (i : ι) := if e i = k then pr (w k) (p i) else 1
-  have hf (k : κ) : pr (w k) (P k) = ∏ i, f k i := by
-    by_cases hk : ∃ i, e i = k
-    · obtain ⟨i, rfl⟩ := hk
-      have hP : P (e i) = p i := funext fun x => propext
-        ⟨fun h => h i rfl, fun h j hj => (he hj).symm ▸ h⟩
-      rw [hP]
-      symm
-      rw [Finset.prod_eq_single i]
-      · simp [f]
-      · intro j _ hj
-        simp [f, show e j ≠ e i from he.ne hj]
-      · simp
-    · push Not at hk
-      have hP : P k = (fun _ => True) := funext fun _ => propext
-        ⟨fun _ => trivial, fun _ j hj => (hk j hj).elim⟩
-      simp [hP, (hw k).total, f, hk]
-  simp_rw [hf]
-  rw [Finset.prod_comm]
-  simp [f]
-
-theorem prodW_map_inj {e : ι → κ} (he : Function.Injective e)
-    {w : κ → Wgt α} (hw : ∀ k, IsLaw (w k)) :
-    mapW (prodW (β := fun _ => α) w) (fun x : κ → α => fun i : ι => x (e i)) =
-      prodW (β := fun _ => α) (fun i => w (e i)) := by
-  funext x
-  unfold mapW
-  simp_rw [funext_iff]
-  have h := prodW_pr_inj he hw (fun i y => y = x i)
-  simp_rw [pr_point'] at h
-  exact h
-
-/-- Mapping to ordered pairs along a disjoint family of positions. -/
-theorem prodW_map_pairs (e : ι ⊕ ι → κ) (he : Function.Injective e)
-    {w : Wgt α} (hw : IsLaw w) :
-    mapW (prodW (fun _ : κ => w))
-      (fun x i => (x (e (.inl i)), x (e (.inr i)))) =
-      prodW (fun _ : ι => pairW w w) := by
-  funext y
-  let p (j : ι ⊕ ι) (x : α) := j.elim (fun i => x = (y i).1) (fun i => x = (y i).2)
-  have heq (x : κ → α) :
-      ((fun i => (x (e (.inl i)), x (e (.inr i)))) = y) ↔ ∀ j, p j (x (e j)) := by
-    simp [funext_iff, Prod.ext_iff, p, Sum.forall, forall_and]
-  unfold mapW
-  simp_rw [heq]
-  have h := prodW_pr_inj he (w:=fun _ => w) (fun _ => hw) p
-  rw [h]
-  simp [Fintype.prod_sum_type, p, prodW, pairW, Finset.prod_mul_distrib]
-
-end
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.FiniteLaws
+import Mathlib.Data.Fintype.Pi
+import Mathlib.Algebra.BigOperators.GroupWithZero.Finset
+
+namespace OAI
+
+/-! # Product Laws -/
+
+noncomputable section
+open scoped BigOperators
+namespace HadwigerCounterexample
+
+theorem ind_all {ι : Type*} [Fintype ι] (p : ι → Prop) :
+    ind (∀ i, p i) = ∏ i, ind (p i) := by
+  classical
+  simp [ind, Fintype.prod_ite_zero]
+
+variable {ι κ α : Type*}
+variable {β : ι → Type*}
+
+def prodW [Fintype ι] (w : ∀ i, Wgt (β i)) : Wgt (∀ i, β i) := fun x => ∏ i, w i (x i)
+
+section
+variable [Fintype ι] [DecidableEq ι] [∀ i, Fintype (β i)]
+
+theorem prodW_tot (w : ∀ i, Wgt (β i)) : tot (prodW w) = ∏ i, tot (w i) :=
+  (Fintype.prod_sum w).symm
+
+theorem prodW_avg (w f : ∀ i, Wgt (β i)) :
+    avg (prodW w) (prodW f) = ∏ i, avg (w i) (f i) := by
+  simp only [avg, prodW]
+  rw [Fintype.prod_sum]
+  simp only [Finset.prod_mul_distrib]
+
+theorem prodW_pr (w : ∀ i, Wgt (β i)) (p : ∀ i, β i → Prop) :
+    pr (prodW w) (fun x => ∀ i, p i (x i)) = ∏ i, pr (w i) (p i) := by
+  simp_rw [pr, ind_all]
+  exact prodW_avg w (fun i x => ind (p i x))
+
+omit [DecidableEq ι] [∀ i, Fintype (β i)] in
+theorem prodW_nonneg {w : ∀ i, Wgt (β i)} (h : ∀ i x, 0 ≤ w i x) (x) : 0 ≤ prodW w x :=
+  Finset.prod_nonneg (fun i _ => h i _)
+
+theorem prodW_law {w : ∀ i, Wgt (β i)} (hw : ∀ i, IsLaw (w i)) : IsLaw (prodW w) := by
+  refine ⟨prodW_nonneg (fun i => (hw i).nz), ?_⟩
+  rw [prodW_tot]
+  simp_rw [(hw _).total]
+  simp
+
+end
+
+section
+variable [Fintype ι] [Fintype κ] [Fintype α] [DecidableEq κ]
+/-- Observe distinct coordinates of a (constant-type) product law. -/
+theorem prodW_pr_inj {e : ι → κ} (he : Function.Injective e)
+    {w : κ → Wgt α} (hw : ∀ k, IsLaw (w k)) (p : ι → α → Prop) :
+    pr (prodW (β:=fun _ => α) w) (fun x => ∀ i, p i (x (e i))) =
+      ∏ i, pr (w (e i)) (p i) := by
+  classical
+  let P (k : κ) (x : α) := ∀ i, e i = k → p i x
+  have h (x : κ → α) : (∀ i, p i (x (e i))) ↔ ∀ k, P k (x k) :=
+    ⟨fun h k i hi => hi ▸ h i, fun h i => h (e i) i rfl⟩
+  simp_rw [h]
+  rw [prodW_pr _ P]
+  let f (k : κ) (i : ι) := if e i = k then pr (w k) (p i) else 1
+  have hf (k : κ) : pr (w k) (P k) = ∏ i, f k i := by
+    by_cases hk : ∃ i, e i = k
+    · obtain ⟨i, rfl⟩ := hk
+      have hP : P (e i) = p i := funext fun x => propext
+        ⟨fun h => h i rfl, fun h j hj => (he hj).symm ▸ h⟩
+      rw [hP]
+      symm
+      rw [Finset.prod_eq_single i]
+      · simp [f]
+      · intro j _ hj
+        simp [f, show e j ≠ e i from he.ne hj]
+      · simp
+    · push Not at hk
+      have hP : P k = (fun _ => True) := funext fun _ => propext
+        ⟨fun _ => trivial, fun _ j hj => (hk j hj).elim⟩
+      simp [hP, (hw k).total, f, hk]
+  simp_rw [hf]
+  rw [Finset.prod_comm]
+  simp [f]
+
+theorem prodW_map_inj {e : ι → κ} (he : Function.Injective e)
+    {w : κ → Wgt α} (hw : ∀ k, IsLaw (w k)) :
+    mapW (prodW (β := fun _ => α) w) (fun x : κ → α => fun i : ι => x (e i)) =
+      prodW (β := fun _ => α) (fun i => w (e i)) := by
+  funext x
+  unfold mapW
+  simp_rw [funext_iff]
+  have h := prodW_pr_inj he hw (fun i y => y = x i)
+  simp_rw [pr_point'] at h
+  exact h
+
+/-- Mapping to ordered pairs along a disjoint family of positions. -/
+theorem prodW_map_pairs (e : ι ⊕ ι → κ) (he : Function.Injective e)
+    {w : Wgt α} (hw : IsLaw w) :
+    mapW (prodW (fun _ : κ => w))
+      (fun x i => (x (e (.inl i)), x (e (.inr i)))) =
+      prodW (fun _ : ι => pairW w w) := by
+  funext y
+  let p (j : ι ⊕ ι) (x : α) := j.elim (fun i => x = (y i).1) (fun i => x = (y i).2)
+  have heq (x : κ → α) :
+      ((fun i => (x (e (.inl i)), x (e (.inr i)))) = y) ↔ ∀ j, p j (x (e j)) := by
+    simp [funext_iff, Prod.ext_iff, p, Sum.forall, forall_and]
+  unfold mapW
+  simp_rw [heq]
+  have h := prodW_pr_inj he (w:=fun _ => w) (fun _ => hw) p
+  rw [h]
+  simp [Fintype.prod_sum_type, p, prodW, pairW, Finset.prod_mul_distrib]
+
+end
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/ProjectedSurrogates.lean

@@ -1,159 +1,159 @@
-import OAI.Combinatorics.HadwigerCounterexample.CommonPartitions
-
-namespace OAI
-
-/-! # Projected Surrogates -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Finset Real Function
-open scoped BigOperators
-variable {A B I J : Type} [Fintype A] [Fintype B] [Fintype I] [Fintype J]
-
-def bower (f : Wgt A) := (∀ i,0≤ f i)∧ (∀ i,f i≤1)
-omit [Fintype B] in
-theorem book_order (w : Wgt A) (p : A→ B) (hw : IsLaw w)
-    (f g : Wgt A) (h : ∀ i, f i≤ g i) (x) :
-    cashbook w p f x ≤ cashbook w p g x := by
-  apply div_le_div_of_nonneg_right _ (map_nz hw.nz p x)
-  exact pr_mono_left (fun i=> mul_le_mul_of_nonneg_left (h i) (hw.nz i)) _
-omit [Fintype B] in
-theorem book_nonneg (w : Wgt A) (p : A→B) (hw : IsLaw w) (f : Wgt A) (hf : ∀ i,0 ≤ f i) (x) :
-    0 ≤ cashbook w p f x := div_nonneg (pr_nonneg (fun i=>mul_nonneg (hw.nz i) (hf i))) (map_nz hw.nz p x)
-omit [Fintype B] in
-theorem garden (w f : Wgt A) (p : A→B) (hw : IsLaw w) (hf : bower f) :
-    bower (banner w p f) := by
-  refine ⟨fun i=> book_nonneg w p hw f hf.1 _,fun i=>?_⟩
-  exact (le_abs_self _).trans (cashbook_bound w hw.nz p f 1 zero_le_one (fun i=>by
-    rw [abs_of_nonneg (hf.1 _)]; exact hf.2 _) _)
-theorem projected_min (w : Wgt A) (p : A→B) (hw : IsLaw w) (f g : Wgt A)
-    (hf : bower f) (hg : bower g) :
-    dip w f g ^2 ≤ dip w (banner w p f) (banner w p g) := by
-  let h i := f i*g i
-  let u := banner w p h
-  have hi : dip w f g=avg w u := by
-    have hh := cash_orth w hw.nz p h (fun _=>1)
-    simpa only [dip,u,Function.comp_apply,mul_one,h] using hh.symm
-  have hh (i) :
-      u i^2 ≤ banner w p f i*banner w p g i := by
-    have h0 : bower u := garden w h p hw ⟨fun i=>mul_nonneg (hf.1 _) (hg.1 _),fun i=>
-      (mul_le_mul (hf.2 _) (hg.2 _) (hg.1 _) zero_le_one).trans_eq (one_mul _)⟩
-    have h1 (i) : h i≤ f i :=
-      ((mul_le_mul_of_nonneg_left (hg.2 _) (hf.1 _)).trans_eq (mul_one _))
-    have h2 (i) : h i≤g i :=
-      ((mul_le_mul_of_nonneg_right (hf.2 _) (hg.1 _)).trans_eq (one_mul _))
-    rw [pow_two]; exact mul_le_mul (book_order w p hw h f h1 _) (book_order w p hw h g h2 _)
-      (h0.1 i) ((garden w f p hw hf).1 i)
-  rw [hi]; exact (mean_sq w hw u).trans (avg_mono hw.nz hh)
-
-def trayLoss (R : ℝ) (u f : Wgt A) := pr f (fun i => R≤density u f i)
-omit [Fintype A] in
-theorem dresso (u f : Wgt A) (h : lsupp f u) : f = fun i => u i*density u f i := by
-  funext i; unfold density
-  by_cases he : f i=0
-  · simp only [he,zero_div,mul_zero]
-  have hh := h i he
-  field_simp
-
-theorem density_error (w : Wgt A) (p : A→B) (hw : IsLaw w) (f g : Wgt A) (hz : lsupp g w) :
-    lcost w (banner w p f) (banner w p (density w g))≤
-      varOne (mapW (fun i=>w i*f i) p) (mapW g p) := by
-  classical
-  let x i := |cashbook w p f i-cashbook w p (density w g) i|
-  have he :
-      lcost w (banner w p f) (banner w p (density w g))=avg (mapW w p) x :=
-    (mapW_avg w p x).symm
-  rw [he]; unfold avg varOne
-  refine sum_le_sum fun i _=>?_
-  let V:=mapW w p i; let A:= mapW (fun i=> w i*f i) p i; let B:= mapW g p i
-  have hh : x i= |A-B|/V := by
-    unfold x cashbook A B V
-    rw [← dresso w g hz,←sub_div,abs_div,abs_of_nonneg (map_nz hw.nz ..)]
-  rw [hh]
-  by_cases h : V=0
-  · change V*_ ≤_
-    rw [h,zero_mul]; exact abs_nonneg _
-  change V*(|A-B|/V)≤ |A-B|
-  exact le_of_eq (by field_simp)
-
-theorem density_trim (u f : Wgt A) (h : ∀ i,0≤f i) (hu : IsLaw u)
-    (R : ℝ) (hR : 0≤R) :
-    (∀ i,mcut R u f i ≤ density u f i) ∧ lcost u (density u f) (mcut R u f)≤trayLoss R u f := by
-  have h1 (i:A) : 0≤density u f i := div_nonneg (h _) (hu.nz _)
-  have h2 (i) :
-      mcut R u f i=min (density u f i) R := congrArg (fun x=>min x R) (max_eq_left (h1 _))
-  have h3 (i) := show mcut R u f i ≤ density u f i from le_trans (le_of_eq (h2 i)) (min_le_left ..)
-  refine ⟨h3,Finset.sum_le_sum (fun i _=>?_)⟩
-  change u i*|density u f i-mcut R u f i| ≤ f i* ind _
-  rw [abs_of_nonneg (sub_nonneg.mpr (h3 _)),h2]
-  by_cases hz : R≤density u f i
-  · rw [ind_one hz,mul_one,min_eq_right hz]
-    have hm := hu.nz i
-    by_cases hg : u i=0
-    · rw [hg,zero_mul]; exact h _
-    apply le_trans (mul_le_mul_of_nonneg_left (sub_le_self _ hR) hm) (le_of_eq ?_)
-    unfold density; field_simp
-  rw [ind_zero hz,mul_zero,min_eq_left (le_of_not_ge hz),sub_self,mul_zero]
-
-private theorem cost_gap (u : Wgt A) (p : A→B) (f g : Wgt A) (h : ∀ i,g i≤ f i)
-    (hu : IsLaw u) :
-    lcost u (banner u p f) (banner u p g)=lcost u f g := by
-  have hf (i : A) : |banner u p f i-banner u p g i|=banner u p f i-banner u p g i :=
-    abs_of_nonneg (sub_nonneg.mpr (book_order u p hu g f h _))
-  have hg (f : Wgt A) : avg u f = avg u (banner u p f) := by
-    have hh := cash_orth u hu.nz p f (fun _=>1); simpa only [dip,Function.comp_apply,mul_one] using hh.symm
-  unfold lcost; simp_rw [hf, abs_of_nonneg (sub_nonneg.mpr (h _)), avg_sub]
-  rw [← hg f, ← hg g]
-
-set_option maxHeartbeats 800000 in
-theorem density_mend (u : Wgt A) (hu : IsLaw u) (p : A→B) (R : ℝ) (hR : 0≤ R)
-    (f g x y : Wgt A) (hf : bower f) (hg : bower g) (hx : SubLaw x)
-    (hy : SubLaw y) (h1 : lsupp x u) (h2 : lsupp y u) :
-    let V f g := varOne (mapW (fun i=>u i*f i) p) (mapW g p)+trayLoss R u g
-    dip u f g ^ 2 ≤ overlap u x y + |rebate u (mcut R u x) (mcut R u y) p|+
-      (V f x+V g y) := by
-  classical
-  intro V
-  let F:=banner u p f; let G:=banner u p g
-  let X:=banner u p (mcut R u x); let Y:=banner u p (mcut R u y)
-  have he (f x : Wgt A) (hx : SubLaw x) (h : lsupp x u) :
-      lcost u (banner u p f) (banner u p (mcut R u x)) ≤ V f x := by
-    let F := banner u p f; let X:=banner u p (density u x); let Z:=banner u p (mcut R u x)
-    obtain ⟨h1,h2⟩:=density_trim u x hx.nz hu R hR
-    have hh : lcost u F Z≤lcost u F X+lcost u X Z := by
-      unfold lcost; rw [← avg_add]; exact avg_mono hu.nz fun i=>abs_sub_le _ _ _
-    exact hh.trans (add_le_add (density_error u p hu f x h)
-      (le_trans (cost_gap u p (density u x) _ h1 hu).le h2))
-  have hh i : F i*G i ≤ X i*Y i + (|F i-X i|+|G i-Y i|) := by
-    have hA := (garden u f p hu hf).2 i; have hB := (garden u g p hu hg).2 i
-    have ht : 0≤X i := book_nonneg u p hu _ (fun i=> (mcut_range _ _ _ hR i).1) _
-    have hq : 0≤Y i := book_nonneg u p hu _ (fun i=> (mcut_range _ _ _ hR i).1) _
-    have hp := (garden u f p hu hf).1 i
-    by_cases h : X i≤F i
-    · by_cases h' : Y i≤ G i
-      · nlinarith only [ht,hq,h,h',hA,hB, le_abs_self (F i-X i),le_abs_self (G i-Y i)]
-      have hz := le_of_not_ge h'
-      nlinarith only [h,hB,hz,le_abs_self (F i-X i),abs_nonneg (G i-Y i),ht]
-    have hz := le_of_not_ge h
-    by_cases h' : Y i≤ G i
-    · nlinarith only [hA,hq,h',hz,abs_nonneg (F i-X i),le_abs_self (G i-Y i)]
-    have hi := le_of_not_ge h'
-    nlinarith only [hz,hq,hi,hp,abs_nonneg (F i-X i), abs_nonneg (G i-Y i)]
-  let A:= mcut R u x; let B:=mcut R u y
-  have hz : dip u A B≤overlap u x y :=
-    avg_mono hu.nz (fun i=>mul_le_mul ((density_trim u x hx.nz hu _ hR).1 _)
-      ((density_trim u y hy.nz hu _ hR).1 _) ((mcut_range R u y hR i).1)
-      (div_nonneg (hx.nz _) (hu.nz _)))
-  have h :
-      dip u X Y≤overlap u x y + |rebate u A B p| := by
-    have h : dip u X Y-dip u A B ≤|dip u A B-dip u X Y| := by rw [abs_sub_comm]; exact le_abs_self _
-    change _≤ _+ |dip u A B - dip u X Y|; linarith only [h,hz]
-  have hp := avg_mono hu.nz hh
-  rw [avg_add,avg_add] at hp
-  exact (le_trans (projected_min u p hu f g hf hg) hp).trans
-    (add_le_add h (add_le_add (he f x hx h1) (he g y hy h2)))
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.CommonPartitions
+
+namespace OAI
+
+/-! # Projected Surrogates -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Finset Real Function
+open scoped BigOperators
+variable {A B I J : Type} [Fintype A] [Fintype B] [Fintype I] [Fintype J]
+
+def bower (f : Wgt A) := (∀ i,0≤ f i)∧ (∀ i,f i≤1)
+omit [Fintype B] in
+theorem book_order (w : Wgt A) (p : A→ B) (hw : IsLaw w)
+    (f g : Wgt A) (h : ∀ i, f i≤ g i) (x) :
+    cashbook w p f x ≤ cashbook w p g x := by
+  apply div_le_div_of_nonneg_right _ (map_nz hw.nz p x)
+  exact pr_mono_left (fun i=> mul_le_mul_of_nonneg_left (h i) (hw.nz i)) _
+omit [Fintype B] in
+theorem book_nonneg (w : Wgt A) (p : A→B) (hw : IsLaw w) (f : Wgt A) (hf : ∀ i,0 ≤ f i) (x) :
+    0 ≤ cashbook w p f x := div_nonneg (pr_nonneg (fun i=>mul_nonneg (hw.nz i) (hf i))) (map_nz hw.nz p x)
+omit [Fintype B] in
+theorem garden (w f : Wgt A) (p : A→B) (hw : IsLaw w) (hf : bower f) :
+    bower (banner w p f) := by
+  refine ⟨fun i=> book_nonneg w p hw f hf.1 _,fun i=>?_⟩
+  exact (le_abs_self _).trans (cashbook_bound w hw.nz p f 1 zero_le_one (fun i=>by
+    rw [abs_of_nonneg (hf.1 _)]; exact hf.2 _) _)
+theorem projected_min (w : Wgt A) (p : A→B) (hw : IsLaw w) (f g : Wgt A)
+    (hf : bower f) (hg : bower g) :
+    dip w f g ^2 ≤ dip w (banner w p f) (banner w p g) := by
+  let h i := f i*g i
+  let u := banner w p h
+  have hi : dip w f g=avg w u := by
+    have hh := cash_orth w hw.nz p h (fun _=>1)
+    simpa only [dip,u,Function.comp_apply,mul_one,h] using hh.symm
+  have hh (i) :
+      u i^2 ≤ banner w p f i*banner w p g i := by
+    have h0 : bower u := garden w h p hw ⟨fun i=>mul_nonneg (hf.1 _) (hg.1 _),fun i=>
+      (mul_le_mul (hf.2 _) (hg.2 _) (hg.1 _) zero_le_one).trans_eq (one_mul _)⟩
+    have h1 (i) : h i≤ f i :=
+      ((mul_le_mul_of_nonneg_left (hg.2 _) (hf.1 _)).trans_eq (mul_one _))
+    have h2 (i) : h i≤g i :=
+      ((mul_le_mul_of_nonneg_right (hf.2 _) (hg.1 _)).trans_eq (one_mul _))
+    rw [pow_two]; exact mul_le_mul (book_order w p hw h f h1 _) (book_order w p hw h g h2 _)
+      (h0.1 i) ((garden w f p hw hf).1 i)
+  rw [hi]; exact (mean_sq w hw u).trans (avg_mono hw.nz hh)
+
+def trayLoss (R : ℝ) (u f : Wgt A) := pr f (fun i => R≤density u f i)
+omit [Fintype A] in
+theorem dresso (u f : Wgt A) (h : lsupp f u) : f = fun i => u i*density u f i := by
+  funext i; unfold density
+  by_cases he : f i=0
+  · simp only [he,zero_div,mul_zero]
+  have hh := h i he
+  field_simp
+
+theorem density_error (w : Wgt A) (p : A→B) (hw : IsLaw w) (f g : Wgt A) (hz : lsupp g w) :
+    lcost w (banner w p f) (banner w p (density w g))≤
+      varOne (mapW (fun i=>w i*f i) p) (mapW g p) := by
+  classical
+  let x i := |cashbook w p f i-cashbook w p (density w g) i|
+  have he :
+      lcost w (banner w p f) (banner w p (density w g))=avg (mapW w p) x :=
+    (mapW_avg w p x).symm
+  rw [he]; unfold avg varOne
+  refine sum_le_sum fun i _=>?_
+  let V:=mapW w p i; let A:= mapW (fun i=> w i*f i) p i; let B:= mapW g p i
+  have hh : x i= |A-B|/V := by
+    unfold x cashbook A B V
+    rw [← dresso w g hz,←sub_div,abs_div,abs_of_nonneg (map_nz hw.nz ..)]
+  rw [hh]
+  by_cases h : V=0
+  · change V*_ ≤_
+    rw [h,zero_mul]; exact abs_nonneg _
+  change V*(|A-B|/V)≤ |A-B|
+  exact le_of_eq (by field_simp)
+
+theorem density_trim (u f : Wgt A) (h : ∀ i,0≤f i) (hu : IsLaw u)
+    (R : ℝ) (hR : 0≤R) :
+    (∀ i,mcut R u f i ≤ density u f i) ∧ lcost u (density u f) (mcut R u f)≤trayLoss R u f := by
+  have h1 (i:A) : 0≤density u f i := div_nonneg (h _) (hu.nz _)
+  have h2 (i) :
+      mcut R u f i=min (density u f i) R := congrArg (fun x=>min x R) (max_eq_left (h1 _))
+  have h3 (i) := show mcut R u f i ≤ density u f i from le_trans (le_of_eq (h2 i)) (min_le_left ..)
+  refine ⟨h3,Finset.sum_le_sum (fun i _=>?_)⟩
+  change u i*|density u f i-mcut R u f i| ≤ f i* ind _
+  rw [abs_of_nonneg (sub_nonneg.mpr (h3 _)),h2]
+  by_cases hz : R≤density u f i
+  · rw [ind_one hz,mul_one,min_eq_right hz]
+    have hm := hu.nz i
+    by_cases hg : u i=0
+    · rw [hg,zero_mul]; exact h _
+    apply le_trans (mul_le_mul_of_nonneg_left (sub_le_self _ hR) hm) (le_of_eq ?_)
+    unfold density; field_simp
+  rw [ind_zero hz,mul_zero,min_eq_left (le_of_not_ge hz),sub_self,mul_zero]
+
+private theorem cost_gap (u : Wgt A) (p : A→B) (f g : Wgt A) (h : ∀ i,g i≤ f i)
+    (hu : IsLaw u) :
+    lcost u (banner u p f) (banner u p g)=lcost u f g := by
+  have hf (i : A) : |banner u p f i-banner u p g i|=banner u p f i-banner u p g i :=
+    abs_of_nonneg (sub_nonneg.mpr (book_order u p hu g f h _))
+  have hg (f : Wgt A) : avg u f = avg u (banner u p f) := by
+    have hh := cash_orth u hu.nz p f (fun _=>1); simpa only [dip,Function.comp_apply,mul_one] using hh.symm
+  unfold lcost; simp_rw [hf, abs_of_nonneg (sub_nonneg.mpr (h _)), avg_sub]
+  rw [← hg f, ← hg g]
+
+set_option maxHeartbeats 800000 in
+theorem density_mend (u : Wgt A) (hu : IsLaw u) (p : A→B) (R : ℝ) (hR : 0≤ R)
+    (f g x y : Wgt A) (hf : bower f) (hg : bower g) (hx : SubLaw x)
+    (hy : SubLaw y) (h1 : lsupp x u) (h2 : lsupp y u) :
+    let V f g := varOne (mapW (fun i=>u i*f i) p) (mapW g p)+trayLoss R u g
+    dip u f g ^ 2 ≤ overlap u x y + |rebate u (mcut R u x) (mcut R u y) p|+
+      (V f x+V g y) := by
+  classical
+  intro V
+  let F:=banner u p f; let G:=banner u p g
+  let X:=banner u p (mcut R u x); let Y:=banner u p (mcut R u y)
+  have he (f x : Wgt A) (hx : SubLaw x) (h : lsupp x u) :
+      lcost u (banner u p f) (banner u p (mcut R u x)) ≤ V f x := by
+    let F := banner u p f; let X:=banner u p (density u x); let Z:=banner u p (mcut R u x)
+    obtain ⟨h1,h2⟩:=density_trim u x hx.nz hu R hR
+    have hh : lcost u F Z≤lcost u F X+lcost u X Z := by
+      unfold lcost; rw [← avg_add]; exact avg_mono hu.nz fun i=>abs_sub_le _ _ _
+    exact hh.trans (add_le_add (density_error u p hu f x h)
+      (le_trans (cost_gap u p (density u x) _ h1 hu).le h2))
+  have hh i : F i*G i ≤ X i*Y i + (|F i-X i|+|G i-Y i|) := by
+    have hA := (garden u f p hu hf).2 i; have hB := (garden u g p hu hg).2 i
+    have ht : 0≤X i := book_nonneg u p hu _ (fun i=> (mcut_range _ _ _ hR i).1) _
+    have hq : 0≤Y i := book_nonneg u p hu _ (fun i=> (mcut_range _ _ _ hR i).1) _
+    have hp := (garden u f p hu hf).1 i
+    by_cases h : X i≤F i
+    · by_cases h' : Y i≤ G i
+      · nlinarith only [ht,hq,h,h',hA,hB, le_abs_self (F i-X i),le_abs_self (G i-Y i)]
+      have hz := le_of_not_ge h'
+      nlinarith only [h,hB,hz,le_abs_self (F i-X i),abs_nonneg (G i-Y i),ht]
+    have hz := le_of_not_ge h
+    by_cases h' : Y i≤ G i
+    · nlinarith only [hA,hq,h',hz,abs_nonneg (F i-X i),le_abs_self (G i-Y i)]
+    have hi := le_of_not_ge h'
+    nlinarith only [hz,hq,hi,hp,abs_nonneg (F i-X i), abs_nonneg (G i-Y i)]
+  let A:= mcut R u x; let B:=mcut R u y
+  have hz : dip u A B≤overlap u x y :=
+    avg_mono hu.nz (fun i=>mul_le_mul ((density_trim u x hx.nz hu _ hR).1 _)
+      ((density_trim u y hy.nz hu _ hR).1 _) ((mcut_range R u y hR i).1)
+      (div_nonneg (hx.nz _) (hu.nz _)))
+  have h :
+      dip u X Y≤overlap u x y + |rebate u A B p| := by
+    have h : dip u X Y-dip u A B ≤|dip u A B-dip u X Y| := by rw [abs_sub_comm]; exact le_abs_self _
+    change _≤ _+ |dip u A B - dip u X Y|; linarith only [h,hz]
+  have hp := avg_mono hu.nz hh
+  rw [avg_add,avg_add] at hp
+  exact (le_trans (projected_min u p hu f g hf hg) hp).trans
+    (add_le_add h (add_le_add (he f x hx h1) (he g y hy h2)))
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/ProjectionEnergy.lean

@@ -1,129 +1,129 @@
-import OAI.Combinatorics.HadwigerCounterexample.RelativeEntropy
-
-namespace OAI
-
-/-! # Projection Energy -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Finset Real
-open scoped BigOperators
-variable {A B C : Type} [Fintype A] [Fintype B] [Fintype C]
-
-theorem map_mass (p : Wgt A) (f : A→B) : tot (mapW p f)=tot p := by
-  simpa only [avg_const,mul_one] using mapW_avg p f (fun _ => 1)
-omit [Fintype B] in
-theorem map_nz {p : Wgt A} (hp : ∀ i, 0 ≤ p i) (f : A→B) (i : B) :
-    0 ≤ mapW p f i := pr_nonneg hp
-omit [Fintype B] in
-theorem lsupp_witness {p : Wgt A} {f : A→B} {i}
-    (h : mapW p f i≠0) : ∃ x,p x≠0 ∧ f x=i := by
-  classical
-  by_contra! hh
-  refine h (Finset.sum_eq_zero (fun x _ => ?_))
-  by_cases h : p x=0
-  · change p x * ind _=0
-    rw [h,zero_mul]
-  exact (congrArg (p x * ·) (ind_zero (hh x h))).trans (mul_zero _)
-
-omit [Fintype B] in
-theorem lsupp_hit {p : Wgt A} (hp : ∀ i,0 ≤ p i) (f : A→B) (x : A) (h : p x≠0) :
-    mapW p f (f x)≠0 := by
-  have h' := lt_of_le_of_ne (hp x) (Ne.symm h)
-  have he := weight_le_tot (fun y => mul_nonneg (hp y) (ind_nonneg (f y = f x))) x
-  simp only [ind_true,mul_one] at he
-  exact (h'.trans_le he).ne'
-
-omit [Fintype B] in
-theorem lsupp.map {p q : Wgt A} (h : lsupp p q) (hq : ∀ i,0 ≤ q i)
-    (f : A→B) : lsupp (mapW p f) (mapW q f) := by
-  intro i hi
-  obtain ⟨x,hx,rfl⟩ := lsupp_witness hi
-  exact lsupp_hit hq f x (h x hx)
-
-omit [Fintype C] in
-theorem map_nested {p : Wgt A} (f : A→B) (g : B→C) :
-    mapW (mapW p f) g = mapW p (g ∘ f) := funext fun _ => mapW_pr p f _
-
-omit [Fintype C] in
-theorem map_mix (w : Wgt A) (p : A→ Wgt B) (f : B→C) :
-    mapW (mixW w p) f = mixW w (fun i => mapW (p i) f) := funext fun _ => mixW_avg ..
-
-omit [Fintype B] in
-theorem map_resize (p : Wgt A) (f : A→B) (u : Wgt B) :
-    mapW (fun i => p i*u (f i)) f = (fun i => mapW p f i * u i) := by
-  funext i
-  unfold mapW pr avg
-  rw [Finset.sum_mul]
-  apply sum_congr rfl
-  intro j _
-  by_cases h : f j=i
-  · simp only [h,ind_true,mul_one]
-  simp only [ind_zero h,mul_zero,zero_mul]
-
-def pour (q : Wgt A) (f : A→B) (w : Wgt B) :=
-  fun i => q i * (w (f i) / mapW q f (f i))
-
-omit [Fintype B] in
-theorem map_pour (q : Wgt A) (f : A → B) (w : Wgt B) (h : lsupp w (mapW q f)) :
-    mapW (pour q f w) f=w := by
-  unfold pour
-  rw [map_resize (u:=fun i => w i / mapW q f i)]
-  funext i
-  by_cases he : w i=0
-  · simp only [he,zero_div,mul_zero]
-  have hm := h i he
-  field_simp
-
-def bucket (q : Wgt A) (f : A→B) (p : Wgt A) := pour q f (mapW p f)
-
-omit [Fintype B] in
-theorem pour_nz {q : Wgt A} {u : Wgt B} (f : A→B)
-    (hq : ∀ i,0 ≤ q i) (hu : ∀ i,0 ≤ u i) (i) : 0 ≤ pour q f u i :=
-  mul_nonneg (hq i) (div_nonneg (hu _) (map_nz hq f _))
-
-omit [Fintype B] in
-theorem bucket_scale (q p : Wgt A) (hq : ∀ i,0≤q i) (h : lsupp p q) (f : A→B) :
-    mapW (bucket q f p) f=mapW p f := map_pour q f _ (lsupp.map h hq f)
-
-theorem bucket_law {q p : Wgt A} (hp : IsLaw p)
-    (f : A→B) (hq : ∀ i,0≤q i) (h : lsupp p q) :
-    IsLaw (bucket q f p) := by
-  refine ⟨pour_nz f hq (map_nz hp.nz f),?_⟩
-  rw [←map_mass _ f,bucket_scale q p hq h,map_mass,hp.total]
-
-omit [Fintype B] in
-theorem lsupp_bucket {p q : Wgt A} (f : A → B) (hp : ∀ i, 0 ≤ p i)
-    (hq : ∀ i,0 ≤ q i) (h : lsupp p q) : lsupp p (bucket q f p) :=
-  fun x hx => mul_ne_zero (h x hx) (div_ne_zero (lsupp_hit hp f x hx) (lsupp_hit hq f x (h x hx)))
-
-omit [Fintype C] in
-theorem bucket_nested (q p : Wgt A) (f : A→B) (g : B→C) :
-    mapW (bucket q (g ∘ f) p) f=bucket (mapW q f) g (mapW p f) := by
-  unfold bucket pour
-  rw [map_nested,map_nested]
-  have h := map_resize q f (fun i=>mapW p (g∘f) (g i)/mapW q (g∘f) (g i))
-  exact h
-
-omit [Fintype B] in
-theorem bucket_mix (q : Wgt A) (f : A → B) (w : Wgt C) (p : C→ Wgt A) :
-    bucket q f (mixW w p)=mixW w (fun y => bucket q f (p y)) := by
-  unfold bucket pour
-  rw [map_mix]
-  funext i; simp only [mixW,avg_mul',avg_div]
-
-theorem tension_stage (p q : Wgt A) (hp : ∀ i,0 ≤ p i) (hq : ∀ i, 0≤ q i)
-    (h : lsupp p q) (f : A→B) :
-    tension p q=tension p (bucket q f p)+tension (mapW p f) (mapW q f) := by
-  unfold tension
-  rw [mapW_avg, ← avg_add]
-  refine avg_congr (fun i hi => ?_)
-  have hu := h i hi; have hw := lsupp_hit hp f i hi; have hv := lsupp_hit hq f i hu
-  dsimp only [bucket,pour]
-  rw [log_mul hu (div_ne_zero hw hv),log_div hw hv]
-  ring
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.RelativeEntropy
+
+namespace OAI
+
+/-! # Projection Energy -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Finset Real
+open scoped BigOperators
+variable {A B C : Type} [Fintype A] [Fintype B] [Fintype C]
+
+theorem map_mass (p : Wgt A) (f : A→B) : tot (mapW p f)=tot p := by
+  simpa only [avg_const,mul_one] using mapW_avg p f (fun _ => 1)
+omit [Fintype B] in
+theorem map_nz {p : Wgt A} (hp : ∀ i, 0 ≤ p i) (f : A→B) (i : B) :
+    0 ≤ mapW p f i := pr_nonneg hp
+omit [Fintype B] in
+theorem lsupp_witness {p : Wgt A} {f : A→B} {i}
+    (h : mapW p f i≠0) : ∃ x,p x≠0 ∧ f x=i := by
+  classical
+  by_contra! hh
+  refine h (Finset.sum_eq_zero (fun x _ => ?_))
+  by_cases h : p x=0
+  · change p x * ind _=0
+    rw [h,zero_mul]
+  exact (congrArg (p x * ·) (ind_zero (hh x h))).trans (mul_zero _)
+
+omit [Fintype B] in
+theorem lsupp_hit {p : Wgt A} (hp : ∀ i,0 ≤ p i) (f : A→B) (x : A) (h : p x≠0) :
+    mapW p f (f x)≠0 := by
+  have h' := lt_of_le_of_ne (hp x) (Ne.symm h)
+  have he := weight_le_tot (fun y => mul_nonneg (hp y) (ind_nonneg (f y = f x))) x
+  simp only [ind_true,mul_one] at he
+  exact (h'.trans_le he).ne'
+
+omit [Fintype B] in
+theorem lsupp.map {p q : Wgt A} (h : lsupp p q) (hq : ∀ i,0 ≤ q i)
+    (f : A→B) : lsupp (mapW p f) (mapW q f) := by
+  intro i hi
+  obtain ⟨x,hx,rfl⟩ := lsupp_witness hi
+  exact lsupp_hit hq f x (h x hx)
+
+omit [Fintype C] in
+theorem map_nested {p : Wgt A} (f : A→B) (g : B→C) :
+    mapW (mapW p f) g = mapW p (g ∘ f) := funext fun _ => mapW_pr p f _
+
+omit [Fintype C] in
+theorem map_mix (w : Wgt A) (p : A→ Wgt B) (f : B→C) :
+    mapW (mixW w p) f = mixW w (fun i => mapW (p i) f) := funext fun _ => mixW_avg ..
+
+omit [Fintype B] in
+theorem map_resize (p : Wgt A) (f : A→B) (u : Wgt B) :
+    mapW (fun i => p i*u (f i)) f = (fun i => mapW p f i * u i) := by
+  funext i
+  unfold mapW pr avg
+  rw [Finset.sum_mul]
+  apply sum_congr rfl
+  intro j _
+  by_cases h : f j=i
+  · simp only [h,ind_true,mul_one]
+  simp only [ind_zero h,mul_zero,zero_mul]
+
+def pour (q : Wgt A) (f : A→B) (w : Wgt B) :=
+  fun i => q i * (w (f i) / mapW q f (f i))
+
+omit [Fintype B] in
+theorem map_pour (q : Wgt A) (f : A → B) (w : Wgt B) (h : lsupp w (mapW q f)) :
+    mapW (pour q f w) f=w := by
+  unfold pour
+  rw [map_resize (u:=fun i => w i / mapW q f i)]
+  funext i
+  by_cases he : w i=0
+  · simp only [he,zero_div,mul_zero]
+  have hm := h i he
+  field_simp
+
+def bucket (q : Wgt A) (f : A→B) (p : Wgt A) := pour q f (mapW p f)
+
+omit [Fintype B] in
+theorem pour_nz {q : Wgt A} {u : Wgt B} (f : A→B)
+    (hq : ∀ i,0 ≤ q i) (hu : ∀ i,0 ≤ u i) (i) : 0 ≤ pour q f u i :=
+  mul_nonneg (hq i) (div_nonneg (hu _) (map_nz hq f _))
+
+omit [Fintype B] in
+theorem bucket_scale (q p : Wgt A) (hq : ∀ i,0≤q i) (h : lsupp p q) (f : A→B) :
+    mapW (bucket q f p) f=mapW p f := map_pour q f _ (lsupp.map h hq f)
+
+theorem bucket_law {q p : Wgt A} (hp : IsLaw p)
+    (f : A→B) (hq : ∀ i,0≤q i) (h : lsupp p q) :
+    IsLaw (bucket q f p) := by
+  refine ⟨pour_nz f hq (map_nz hp.nz f),?_⟩
+  rw [←map_mass _ f,bucket_scale q p hq h,map_mass,hp.total]
+
+omit [Fintype B] in
+theorem lsupp_bucket {p q : Wgt A} (f : A → B) (hp : ∀ i, 0 ≤ p i)
+    (hq : ∀ i,0 ≤ q i) (h : lsupp p q) : lsupp p (bucket q f p) :=
+  fun x hx => mul_ne_zero (h x hx) (div_ne_zero (lsupp_hit hp f x hx) (lsupp_hit hq f x (h x hx)))
+
+omit [Fintype C] in
+theorem bucket_nested (q p : Wgt A) (f : A→B) (g : B→C) :
+    mapW (bucket q (g ∘ f) p) f=bucket (mapW q f) g (mapW p f) := by
+  unfold bucket pour
+  rw [map_nested,map_nested]
+  have h := map_resize q f (fun i=>mapW p (g∘f) (g i)/mapW q (g∘f) (g i))
+  exact h
+
+omit [Fintype B] in
+theorem bucket_mix (q : Wgt A) (f : A → B) (w : Wgt C) (p : C→ Wgt A) :
+    bucket q f (mixW w p)=mixW w (fun y => bucket q f (p y)) := by
+  unfold bucket pour
+  rw [map_mix]
+  funext i; simp only [mixW,avg_mul',avg_div]
+
+theorem tension_stage (p q : Wgt A) (hp : ∀ i,0 ≤ p i) (hq : ∀ i, 0≤ q i)
+    (h : lsupp p q) (f : A→B) :
+    tension p q=tension p (bucket q f p)+tension (mapW p f) (mapW q f) := by
+  unfold tension
+  rw [mapW_avg, ← avg_add]
+  refine avg_congr (fun i hi => ?_)
+  have hu := h i hi; have hw := lsupp_hit hp f i hi; have hv := lsupp_hit hq f i hu
+  dsimp only [bucket,pour]
+  rw [log_mul hu (div_ne_zero hw hv),log_div hw hv]
+  ring
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/ProjectionError.lean

@@ -1,100 +1,100 @@
-import OAI.Combinatorics.HadwigerCounterexample.ResidualRegularity
-
-namespace OAI
-
-/-! # Projection Error -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Finset Matrix LinearMap Module Filter Function
-open scoped BigOperators
-variable {A B I : Type} [Fintype A] [Fintype B] [Fintype I]
-
-def rebate (u f g : Wgt A) (p : A→B) :=
-  dip u f g - dip u (banner u p f) (banner u p g)
-omit [Fintype B] in
-theorem rebate_sym (u f g : Wgt A) (p : A→B) :
-    rebate u f g p=rebate u g f p := by unfold rebate; rw [dip_sym u f,dip_sym u (banner u p f)]
-theorem rebate_calc (u f g : Wgt A) (p : A→B) (hu : ∀ i,0≤u i) :
-    rebate u f g p=dip u (fun i=>f i-banner u p f i) g := by
-  unfold rebate
-  rw [dip_sub,dip_sym u (banner u p f) (banner u p g)]
-  exact congrArg (dip u f g - ·) ((show dip u (banner u p g) (banner u p f)=dip u g (banner u p f) from
-    cash_orth u hu p g (cashbook u p f)).trans (dip_sym ..))
-def lcost (u f g : Wgt A) := avg u (fun i=>|f i-g i|)
-
-theorem rebate_cost (u f g f' : Wgt A) (p : A→B) (hu : ∀ i,0≤u i)
-    (r : ℝ) (hr : 0 ≤ r) (h : ∀ i,|g i|≤r) :
-    |rebate u f g p-rebate u f' g p| ≤ lcost u f f' * (2*r) := by
-  rw [rebate_sym u f g,rebate_sym u f' g,rebate_calc u g f p hu,rebate_calc u g f' p hu]
-  unfold dip; rw [←avg_sub]
-  apply (abs_avg_le hu).trans
-  have hz i : |g i-banner u p g i|≤2*r :=
-    ((abs_sub ..).trans (add_le_add (h i) (cashbook_bound u hu p g r hr h (p i)))).trans_eq
-      (two_mul _).symm
-  unfold lcost; rw [←avg_mul]; apply avg_mono hu
-  intro i
-  dsimp only
-  rw [←mul_sub,abs_mul,mul_comm]
-  exact mul_le_mul_of_nonneg_left (hz _) (abs_nonneg _)
-
-def syrup (r : ℝ) (x : ℝ) := min (max x 0) r
-def mcut (r : ℝ) (u : Wgt A) (f : Wgt A) := syrup r ∘ density u f
-theorem syrup_range (r x : ℝ) (h : 0≤r) :
-    0≤ syrup r x∧ syrup r x ≤ r := ⟨le_min (le_max_right ..) h,min_le_right ..⟩
-omit [Fintype A] in
-theorem mcut_range (r : ℝ) (u f : Wgt A) (h : 0≤r) (x) :
-    0≤mcut r u f x∧mcut r u f x ≤ r := syrup_range _ _ h
-
-private theorem jelly (r x y : ℝ) :
-    |syrup r x-syrup r y| ≤ |x-y| := by
-  wlog hh : x≤y generalizing x y
-  · rw [abs_sub_comm,abs_sub_comm x y]; exact this y x (le_of_not_ge hh)
-  have hr : syrup r x ≤ syrup r y := min_le_min (max_le_max hh le_rfl) le_rfl
-  rw [abs_of_nonpos (sub_nonpos.mpr hh),abs_of_nonpos (sub_nonpos.mpr hr)]
-  unfold syrup
-  rcases le_total x 0 with h|h <;> rcases le_total y 0 with he|he
-  · rw [max_eq_right h,max_eq_right he]; linarith only [hh]
-  · rw [max_eq_right h,max_eq_left he]; rcases le_total 0 r with h'|h'
-    · rw [min_eq_left h']
-      linarith only [h, min_le_left y r]
-    rw [min_eq_right h',min_eq_right (by linarith)]
-    linarith
-  · obtain rfl : x=y := by linarith
-    simp
-  rw [max_eq_left h,max_eq_left he]
-  rcases le_total x r with h'|h'
-  · rw [min_eq_left h']; linarith only [min_le_left y r]
-  rw [min_eq_right h',min_eq_right (by linarith)]; linarith
-
-theorem mcut_cost (r : ℝ) (u f g : Wgt A) (hu : ∀ i,0≤u i) :
-    lcost u (mcut r u f) (mcut r u g)≤ varOne f g := by
-  unfold lcost avg varOne; refine sum_le_sum fun i _ => ?_
-  apply (mul_le_mul_of_nonneg_left (jelly r (density u f i) (density u g i)) (hu i)).trans
-  by_cases hx : u i=0
-  · rw [hx,zero_mul]; exact abs_nonneg _
-  unfold density; rw [←sub_div,abs_div,abs_of_nonneg (hu _)]
-  exact le_of_eq (by field_simp)
-
-set_option maxHeartbeats 500000 in
-theorem roster_clip (r : ℝ) (u : Wgt A) (hu : IsLaw u) (hr : 0≤r) (Q : Wgt A→ Prop)
-    (k : ℕ) (ε : ℝ) (h : roster Q k ε) :
-    ∃ f : Fin (k+1)→Wgt A,(∀ i x,|f i x|≤r) ∧
-      ∀ w,Q w→∃ i,lcost u (mcut r u w) (f i)≤ ε := by
-  classical
-  obtain ⟨t,ht,v,hv⟩:=h
-  let W:= fun i : Fin (k+1)=> if h:i.val<t then mcut r u (v (⟨i.val,h⟩)) else (fun i:A => 0)
-  refine ⟨W,fun i x=>?_,fun i hi=>?_⟩
-  · unfold W; split
-    next h =>
-      obtain ⟨he,hy⟩:=mcut_range r u (v (⟨i.val,h⟩)) hr x
-      rwa [abs_of_nonneg he]
-    simpa only [abs_zero] using hr
-  obtain ⟨j,hj⟩:=hv i hi
-  exact ⟨⟨j.val,Nat.lt_succ_of_lt (j.isLt.trans_le ht)⟩,by
-    unfold W; rw [dite_eq_left j.isLt]; exact (mcut_cost r u i _ hu.nz).trans hj⟩
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.ResidualRegularity
+
+namespace OAI
+
+/-! # Projection Error -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Finset Matrix LinearMap Module Filter Function
+open scoped BigOperators
+variable {A B I : Type} [Fintype A] [Fintype B] [Fintype I]
+
+def rebate (u f g : Wgt A) (p : A→B) :=
+  dip u f g - dip u (banner u p f) (banner u p g)
+omit [Fintype B] in
+theorem rebate_sym (u f g : Wgt A) (p : A→B) :
+    rebate u f g p=rebate u g f p := by unfold rebate; rw [dip_sym u f,dip_sym u (banner u p f)]
+theorem rebate_calc (u f g : Wgt A) (p : A→B) (hu : ∀ i,0≤u i) :
+    rebate u f g p=dip u (fun i=>f i-banner u p f i) g := by
+  unfold rebate
+  rw [dip_sub,dip_sym u (banner u p f) (banner u p g)]
+  exact congrArg (dip u f g - ·) ((show dip u (banner u p g) (banner u p f)=dip u g (banner u p f) from
+    cash_orth u hu p g (cashbook u p f)).trans (dip_sym ..))
+def lcost (u f g : Wgt A) := avg u (fun i=>|f i-g i|)
+
+theorem rebate_cost (u f g f' : Wgt A) (p : A→B) (hu : ∀ i,0≤u i)
+    (r : ℝ) (hr : 0 ≤ r) (h : ∀ i,|g i|≤r) :
+    |rebate u f g p-rebate u f' g p| ≤ lcost u f f' * (2*r) := by
+  rw [rebate_sym u f g,rebate_sym u f' g,rebate_calc u g f p hu,rebate_calc u g f' p hu]
+  unfold dip; rw [←avg_sub]
+  apply (abs_avg_le hu).trans
+  have hz i : |g i-banner u p g i|≤2*r :=
+    ((abs_sub ..).trans (add_le_add (h i) (cashbook_bound u hu p g r hr h (p i)))).trans_eq
+      (two_mul _).symm
+  unfold lcost; rw [←avg_mul]; apply avg_mono hu
+  intro i
+  dsimp only
+  rw [←mul_sub,abs_mul,mul_comm]
+  exact mul_le_mul_of_nonneg_left (hz _) (abs_nonneg _)
+
+def syrup (r : ℝ) (x : ℝ) := min (max x 0) r
+def mcut (r : ℝ) (u : Wgt A) (f : Wgt A) := syrup r ∘ density u f
+theorem syrup_range (r x : ℝ) (h : 0≤r) :
+    0≤ syrup r x∧ syrup r x ≤ r := ⟨le_min (le_max_right ..) h,min_le_right ..⟩
+omit [Fintype A] in
+theorem mcut_range (r : ℝ) (u f : Wgt A) (h : 0≤r) (x) :
+    0≤mcut r u f x∧mcut r u f x ≤ r := syrup_range _ _ h
+
+private theorem jelly (r x y : ℝ) :
+    |syrup r x-syrup r y| ≤ |x-y| := by
+  wlog hh : x≤y generalizing x y
+  · rw [abs_sub_comm,abs_sub_comm x y]; exact this y x (le_of_not_ge hh)
+  have hr : syrup r x ≤ syrup r y := min_le_min (max_le_max hh le_rfl) le_rfl
+  rw [abs_of_nonpos (sub_nonpos.mpr hh),abs_of_nonpos (sub_nonpos.mpr hr)]
+  unfold syrup
+  rcases le_total x 0 with h|h <;> rcases le_total y 0 with he|he
+  · rw [max_eq_right h,max_eq_right he]; linarith only [hh]
+  · rw [max_eq_right h,max_eq_left he]; rcases le_total 0 r with h'|h'
+    · rw [min_eq_left h']
+      linarith only [h, min_le_left y r]
+    rw [min_eq_right h',min_eq_right (by linarith)]
+    linarith
+  · obtain rfl : x=y := by linarith
+    simp
+  rw [max_eq_left h,max_eq_left he]
+  rcases le_total x r with h'|h'
+  · rw [min_eq_left h']; linarith only [min_le_left y r]
+  rw [min_eq_right h',min_eq_right (by linarith)]; linarith
+
+theorem mcut_cost (r : ℝ) (u f g : Wgt A) (hu : ∀ i,0≤u i) :
+    lcost u (mcut r u f) (mcut r u g)≤ varOne f g := by
+  unfold lcost avg varOne; refine sum_le_sum fun i _ => ?_
+  apply (mul_le_mul_of_nonneg_left (jelly r (density u f i) (density u g i)) (hu i)).trans
+  by_cases hx : u i=0
+  · rw [hx,zero_mul]; exact abs_nonneg _
+  unfold density; rw [←sub_div,abs_div,abs_of_nonneg (hu _)]
+  exact le_of_eq (by field_simp)
+
+set_option maxHeartbeats 500000 in
+theorem roster_clip (r : ℝ) (u : Wgt A) (hu : IsLaw u) (hr : 0≤r) (Q : Wgt A→ Prop)
+    (k : ℕ) (ε : ℝ) (h : roster Q k ε) :
+    ∃ f : Fin (k+1)→Wgt A,(∀ i x,|f i x|≤r) ∧
+      ∀ w,Q w→∃ i,lcost u (mcut r u w) (f i)≤ ε := by
+  classical
+  obtain ⟨t,ht,v,hv⟩:=h
+  let W:= fun i : Fin (k+1)=> if h:i.val<t then mcut r u (v (⟨i.val,h⟩)) else (fun i:A => 0)
+  refine ⟨W,fun i x=>?_,fun i hi=>?_⟩
+  · unfold W; split
+    next h =>
+      obtain ⟨he,hy⟩:=mcut_range r u (v (⟨i.val,h⟩)) hr x
+      rwa [abs_of_nonneg he]
+    simpa only [abs_zero] using hr
+  obtain ⟨j,hj⟩:=hv i hi
+  exact ⟨⟨j.val,Nat.lt_succ_of_lt (j.isLt.trans_le ht)⟩,by
+    unfold W; rw [dite_eq_left j.isLt]; exact (mcut_cost r u i _ hu.nz).trans hj⟩
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/ProjectionNets.lean

@@ -1,106 +1,106 @@
-import OAI.Combinatorics.HadwigerCounterexample.RoundedRefinements
-
-namespace OAI
-
-/-! # Projection Nets -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Finset Filter Matrix Real Function
-open scoped BigOperators
-variable {A B C D : Type} [Fintype A] [Fintype B] [Fintype C] [Fintype D]
-
-theorem stamina_equiv (p : Wgt A) (e : A≃C) (a : ℝ)
-    (h : stamina p a) :
-    stamina (mapW p e) a := by
-  intro i hi; rw [mapW_equiv_val] at *
-  exact h _ hi
-
-theorem tension_equiv (p q : Wgt A) (e : A≃C) :
-    tension (mapW p e) (mapW q e)=tension p q := by
-  unfold tension
-  rw [mapW_avg]
-  simp_rw [mapW_equiv_val,Equiv.symm_apply_apply]
-
-theorem budget_equiv (μ : Wgt A) (p : A → Wgt B) (f : B→C) (e : C≃D) :
-    budget μ p (e ∘ f)=budget μ p f := by
-  unfold budget
-  simp_rw [←map_nested f _,tension_equiv]
-
-def ample (μ : Wgt A) (p : A→Wgt B) (r : ℕ) (ε : ℝ) :=
-  ∃ t : ℕ,t ≤ r ∧ ∃ f : B → Fin t,∀ w,catalog μ p w →
-    varOne w (bucket unif f w) ≤ ε
-
-set_option maxHeartbeats 800000 in
-theorem ample_thresh (V ε : ℝ) (hε : 0<ε) :
-    ∃ (r : ℕ) (δ : ℝ),0<δ ∧ ∀ (A B : Type) [Fintype A] [Fintype B] [Nonempty B]
-      (μ : Wgt A) (p : A→ Wgt B), Ultra μ p →
-      tariffs μ p r δ V → ample μ p r ε := by
-  classical
-  let c := ε/8
-  have hc : 0<c := by positivity
-  obtain ⟨α,hα,hα',hh⟩ := ui_threshold V c hc
-  obtain ⟨D,hD⟩ := exists_nat_gt (max 0 (V/c^2))
-  have hd := (max_lt_iff.mp hD).2
-  rw [div_lt_iff₀ (by positivity)] at hd
-  let r := 2^(D+1)
-  have h0 : 0<(r:ℝ) := by unfold r; positivity
-  let k := min (min α c/r) (1/2)
-  have hk : 0<k := lt_min (div_pos (lt_min hα hc) h0) (by norm_num)
-  have hk0 : k≤1/2 := min_le_right ..
-  have hk' : k≤1 := le_trans hk0 (by norm_num)
-  let δ := min α (k^D)
-  have hδ : 0<δ := lt_min hα (pow_pos hk D)
-  refine ⟨r,δ,hδ,fun A B _ _ _ μ p hw hV => ?_⟩
-  let e : Wgt B := unif
-  have he : IsLaw e := unif_law
-  by_contra h
-  have hr2 : 2≤r := by
-    unfold r; rw [pow_succ]
-    have : 0<2^D := by positivity
-    omega
-  have ht := hh A B μ p hw (tariffs_monotone hV hr2 (min_le_left ..))
-  have hstep (n : ℕ) (hn : n≤ D) :
-      ∃ f : B → Fin (2^n), stamina (mapW e f) (k^n) ∧
-        ↑n*c^2 ≤ budget μ p f := by
-    induction n with
-    | zero =>
-      let f := fun _ : B => (0 : Fin (2^0))
-      refine ⟨f,?_,by simpa using budget_nonneg hw f⟩
-      intro i hi
-      have hi : i = 0 := by
-        have hh := i.isLt; norm_num at hh
-        exact Fin.ext (by simp only [Fin.val_zero]; omega)
-      subst i; change 1 ≤ pr e (fun x => f x=0)
-      simp [f,he.total]
-    | succ i ih =>
-      obtain ⟨f,hf,hB⟩ := ih (by omega)
-      let t := 2^i
-      have he' : ∃ w,catalog μ p w ∧ 8*c<varOne w (bucket unif f w) := by
-        by_contra! hh
-        apply h; refine ⟨t,Nat.pow_le_pow_right (by decide) (by omega),f,?_⟩
-        rwa [show 8*c=ε by unfold c; ring] at hh
-      obtain ⟨w,hw',hwv⟩ := he'
-      have hz : num (Fin t × Bool)*k ≤ min α c := by
-        have h1 : Fintype.card (Fin t × Bool) ≤ r :=
-          calc _ = 2^(i+1) := by simp [pow_succ,t]
-               _ ≤ r := Nat.pow_le_pow_right (by decide) (by omega)
-        have h2 := min_le_left (min α c/r) (1/2)
-        change k ≤ min α c/r at h2
-        rw [le_div_iff₀ h0,mul_comm k] at h2
-        exact (mul_le_mul_of_nonneg_right (by exact_mod_cast h1) hk.le).trans h2
-      obtain ⟨F,hF',hF⟩ := divide_progress hw c (k^i) α k hc hk (by linarith)
-        (pow_pos hk _) (pow_le_one₀ hk.le hk') ht f hf hz w hw' hwv
-      let E : (Fin t×Bool)≃ Fin (2^(i+1)) := Fintype.equivFinOfCardEq (by simp [pow_succ,t])
-      refine ⟨E ∘ F,?_,?_⟩
-      · rw [←map_nested,pow_succ' k]; exact stamina_equiv _ E _ hF'
-      rw [budget_equiv,Nat.cast_add,Nat.cast_one]; linarith only [hF,hB]
-  obtain ⟨f,hf,hf'⟩ := hstep D le_rfl
-  have he' : stamina (mapW unif f) δ := fun i hi => (min_le_right ..).trans (hf i hi)
-  have hz := hV _ (f:=f) (by simp; unfold r; rw [pow_succ]; omega) he'
-  exact (not_lt_of_ge (le_trans hf' hz)) hd
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.RoundedRefinements
+
+namespace OAI
+
+/-! # Projection Nets -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Finset Filter Matrix Real Function
+open scoped BigOperators
+variable {A B C D : Type} [Fintype A] [Fintype B] [Fintype C] [Fintype D]
+
+theorem stamina_equiv (p : Wgt A) (e : A≃C) (a : ℝ)
+    (h : stamina p a) :
+    stamina (mapW p e) a := by
+  intro i hi; rw [mapW_equiv_val] at *
+  exact h _ hi
+
+theorem tension_equiv (p q : Wgt A) (e : A≃C) :
+    tension (mapW p e) (mapW q e)=tension p q := by
+  unfold tension
+  rw [mapW_avg]
+  simp_rw [mapW_equiv_val,Equiv.symm_apply_apply]
+
+theorem budget_equiv (μ : Wgt A) (p : A → Wgt B) (f : B→C) (e : C≃D) :
+    budget μ p (e ∘ f)=budget μ p f := by
+  unfold budget
+  simp_rw [←map_nested f _,tension_equiv]
+
+def ample (μ : Wgt A) (p : A→Wgt B) (r : ℕ) (ε : ℝ) :=
+  ∃ t : ℕ,t ≤ r ∧ ∃ f : B → Fin t,∀ w,catalog μ p w →
+    varOne w (bucket unif f w) ≤ ε
+
+set_option maxHeartbeats 800000 in
+theorem ample_thresh (V ε : ℝ) (hε : 0<ε) :
+    ∃ (r : ℕ) (δ : ℝ),0<δ ∧ ∀ (A B : Type) [Fintype A] [Fintype B] [Nonempty B]
+      (μ : Wgt A) (p : A→ Wgt B), Ultra μ p →
+      tariffs μ p r δ V → ample μ p r ε := by
+  classical
+  let c := ε/8
+  have hc : 0<c := by positivity
+  obtain ⟨α,hα,hα',hh⟩ := ui_threshold V c hc
+  obtain ⟨D,hD⟩ := exists_nat_gt (max 0 (V/c^2))
+  have hd := (max_lt_iff.mp hD).2
+  rw [div_lt_iff₀ (by positivity)] at hd
+  let r := 2^(D+1)
+  have h0 : 0<(r:ℝ) := by unfold r; positivity
+  let k := min (min α c/r) (1/2)
+  have hk : 0<k := lt_min (div_pos (lt_min hα hc) h0) (by norm_num)
+  have hk0 : k≤1/2 := min_le_right ..
+  have hk' : k≤1 := le_trans hk0 (by norm_num)
+  let δ := min α (k^D)
+  have hδ : 0<δ := lt_min hα (pow_pos hk D)
+  refine ⟨r,δ,hδ,fun A B _ _ _ μ p hw hV => ?_⟩
+  let e : Wgt B := unif
+  have he : IsLaw e := unif_law
+  by_contra h
+  have hr2 : 2≤r := by
+    unfold r; rw [pow_succ]
+    have : 0<2^D := by positivity
+    omega
+  have ht := hh A B μ p hw (tariffs_monotone hV hr2 (min_le_left ..))
+  have hstep (n : ℕ) (hn : n≤ D) :
+      ∃ f : B → Fin (2^n), stamina (mapW e f) (k^n) ∧
+        ↑n*c^2 ≤ budget μ p f := by
+    induction n with
+    | zero =>
+      let f := fun _ : B => (0 : Fin (2^0))
+      refine ⟨f,?_,by simpa using budget_nonneg hw f⟩
+      intro i hi
+      have hi : i = 0 := by
+        have hh := i.isLt; norm_num at hh
+        exact Fin.ext (by simp only [Fin.val_zero]; omega)
+      subst i; change 1 ≤ pr e (fun x => f x=0)
+      simp [f,he.total]
+    | succ i ih =>
+      obtain ⟨f,hf,hB⟩ := ih (by omega)
+      let t := 2^i
+      have he' : ∃ w,catalog μ p w ∧ 8*c<varOne w (bucket unif f w) := by
+        by_contra! hh
+        apply h; refine ⟨t,Nat.pow_le_pow_right (by decide) (by omega),f,?_⟩
+        rwa [show 8*c=ε by unfold c; ring] at hh
+      obtain ⟨w,hw',hwv⟩ := he'
+      have hz : num (Fin t × Bool)*k ≤ min α c := by
+        have h1 : Fintype.card (Fin t × Bool) ≤ r :=
+          calc _ = 2^(i+1) := by simp [pow_succ,t]
+               _ ≤ r := Nat.pow_le_pow_right (by decide) (by omega)
+        have h2 := min_le_left (min α c/r) (1/2)
+        change k ≤ min α c/r at h2
+        rw [le_div_iff₀ h0,mul_comm k] at h2
+        exact (mul_le_mul_of_nonneg_right (by exact_mod_cast h1) hk.le).trans h2
+      obtain ⟨F,hF',hF⟩ := divide_progress hw c (k^i) α k hc hk (by linarith)
+        (pow_pos hk _) (pow_le_one₀ hk.le hk') ht f hf hz w hw' hwv
+      let E : (Fin t×Bool)≃ Fin (2^(i+1)) := Fintype.equivFinOfCardEq (by simp [pow_succ,t])
+      refine ⟨E ∘ F,?_,?_⟩
+      · rw [←map_nested,pow_succ' k]; exact stamina_equiv _ E _ hF'
+      rw [budget_equiv,Nat.cast_add,Nat.cast_one]; linarith only [hF,hB]
+  obtain ⟨f,hf,hf'⟩ := hstep D le_rfl
+  have he' : stamina (mapW unif f) δ := fun i hi => (min_le_right ..).trans (hf i hi)
+  have hz := hV _ (f:=f) (by simp; unfold r; rw [pow_succ]; omega) he'
+  exact (not_lt_of_ge (le_trans hf' hz)) hd
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/QuadraticFourier.lean

@@ -1,83 +1,83 @@
-import OAI.Combinatorics.HadwigerCounterexample.FreeBlockFourier
-
-namespace OAI
-
-/-! # Quadratic Fourier -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open scoped BigOperators
-open Matrix Module LinearMap Submodule Function Finset
-variable {I J : Type} [Fintype I] [Fintype J] [DecidableEq I] [DecidableEq J]
-
-theorem phase_trans (t : Vec I) (f : Wgt (Vec I)) :
-    avg unif (fun y => f (y+t))=avg unif f := by
-  let E : Vec I ≃ Vec I := ⟨(·+t),(·+t),add_polar t,add_polar t⟩
-  exact avg_bij E unif f
-
-theorem half_power (x a : ℝ) (ha : x^2 ≤ bp a) : |x|≤ bp (a/2) :=
-  le_of_pow_le_pow_left₀ (by decide : 2≠0) (bp_pos _).le (by
-    rw [sq_abs,pow_two (bp _),←bp_add,show a/2+a/2=a by ring]; exact ha)
-
-def polarize (f : Vec I→F) (M : Mat I I) :=
-  ∀ x y,f (x+y)+f x=f y+f 0+dotProduct y (M *ᵥ x)
-
-set_option maxHeartbeats 600000 in
-theorem flare_rank (f : Vec I→F) (M : Mat I I) (h : polarize f M) :
-    |avg unif (fun x => wsign (f x))| ≤ bp (-(M.rank:ℝ)/2) := by
-  classical
-  let g (x : Vec I) := wsign (f x)
-  have hh :
-      avg unif g ^ 2 = avg unif (fun x : Vec I => avg unif (fun y : Vec I =>
-        g (x+y)*g y)) := by
-    have hi (i : Vec I) : avg unif (fun x => g (x+i)*g i)=avg unif g*g i := by
-      rw [avg_mul,phase_trans]
-    rw [avg_avg]; simp_rw [hi,avg_mul']
-    ring
-  let L := Mᵀ
-  have hg x y : g (x+y)*g y= wsign (f x+f 0)*wsign (dotL (L *ᵥ x) y) := by
-    unfold g; rw [← wsign_add,← wsign_add,add_comm x y,h y x]
-    unfold L
-    congr 2
-    change dotProduct x (M *ᵥ y)=dotProduct _ y
-    rw [dotProduct_comm _ y,dotProduct_transpose_mulVec]
-  have hi (x : Vec I) :
-      avg unif (fun y : Vec I => g (x+y)*g y) ≤ ind ((L *ᵥ x)=0) := by
-    simp_rw [hg x,avg_mul',wsign_lin]
-    have he : dotL (L *ᵥ x)=0 ↔ L *ᵥ x=0 := by
-      constructor
-      · exact fun h => dot_ext_zero fun y => by rw [dotProduct_comm]; exact LinearMap.congr_fun h y
-      intro h; rw [h]; exact LinearMap.ext (fun x => zero_dotProduct x)
-    rw [he]
-    exact (mul_le_mul_of_nonneg_right ((le_abs_self _).trans_eq (wsign_abs _))
-      (ind_nonneg _)).trans_eq (one_mul _)
-  refine half_power _ _ (?_)
-  change avg unif g^2≤_
-  rw [hh]
-  refine (avg_mono unif_law.nz hi).trans_eq ?_
-  have he : pr unif (fun x => L.mulVecLin x=0) = _ := pr_unif_lin L.mulVecLin 0
-  rw [ind_one (LinearMap.range L.mulVecLin).zero_mem,one_mul] at he
-  change pr unif _=_
-  exact he.trans (by change bp (-(L.rank:ℝ))=_; rw [show L=Mᵀ from rfl,Matrix.rank_transpose])
-
-omit [DecidableEq I] [DecidableEq J] in
-theorem flare_affine (M : Mat J J) (P : Mat J I) (k : Vec J) (a : F) (i : Vec I) :
-    let Q := fun x => dotProduct i x + (a + evmat M (P *ᵥ x+k) (P *ᵥ x+k))
-    polarize Q (pullM P P (M+Mᵀ)) := by
-  intro Q x y
-  have he : dotProduct y ((pullM P P (M+Mᵀ)) *ᵥ x)=
-      evmat M (P *ᵥ y) (P *ᵥ x) + evmat M (P *ᵥ x) (P *ᵥ y) := by
-    change evmat _ _ _=_
-    rw [evmat_pull,evmat_addM, evmat_transpose]
-  rw [he]
-  unfold Q evmat
-  simp only [dotProduct_zero,Matrix.mulVec_zero,mulVec_add,dotProduct_add,add_dotProduct,
-    zero_add]
-
-  ring_nf
-  simp only [mul_two,char_two,add_zero,zero_add]
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.FreeBlockFourier
+
+namespace OAI
+
+/-! # Quadratic Fourier -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open scoped BigOperators
+open Matrix Module LinearMap Submodule Function Finset
+variable {I J : Type} [Fintype I] [Fintype J] [DecidableEq I] [DecidableEq J]
+
+theorem phase_trans (t : Vec I) (f : Wgt (Vec I)) :
+    avg unif (fun y => f (y+t))=avg unif f := by
+  let E : Vec I ≃ Vec I := ⟨(·+t),(·+t),add_polar t,add_polar t⟩
+  exact avg_bij E unif f
+
+theorem half_power (x a : ℝ) (ha : x^2 ≤ bp a) : |x|≤ bp (a/2) :=
+  le_of_pow_le_pow_left₀ (by decide : 2≠0) (bp_pos _).le (by
+    rw [sq_abs,pow_two (bp _),←bp_add,show a/2+a/2=a by ring]; exact ha)
+
+def polarize (f : Vec I→F) (M : Mat I I) :=
+  ∀ x y,f (x+y)+f x=f y+f 0+dotProduct y (M *ᵥ x)
+
+set_option maxHeartbeats 600000 in
+theorem flare_rank (f : Vec I→F) (M : Mat I I) (h : polarize f M) :
+    |avg unif (fun x => wsign (f x))| ≤ bp (-(M.rank:ℝ)/2) := by
+  classical
+  let g (x : Vec I) := wsign (f x)
+  have hh :
+      avg unif g ^ 2 = avg unif (fun x : Vec I => avg unif (fun y : Vec I =>
+        g (x+y)*g y)) := by
+    have hi (i : Vec I) : avg unif (fun x => g (x+i)*g i)=avg unif g*g i := by
+      rw [avg_mul,phase_trans]
+    rw [avg_avg]; simp_rw [hi,avg_mul']
+    ring
+  let L := Mᵀ
+  have hg x y : g (x+y)*g y= wsign (f x+f 0)*wsign (dotL (L *ᵥ x) y) := by
+    unfold g; rw [← wsign_add,← wsign_add,add_comm x y,h y x]
+    unfold L
+    congr 2
+    change dotProduct x (M *ᵥ y)=dotProduct _ y
+    rw [dotProduct_comm _ y,dotProduct_transpose_mulVec]
+  have hi (x : Vec I) :
+      avg unif (fun y : Vec I => g (x+y)*g y) ≤ ind ((L *ᵥ x)=0) := by
+    simp_rw [hg x,avg_mul',wsign_lin]
+    have he : dotL (L *ᵥ x)=0 ↔ L *ᵥ x=0 := by
+      constructor
+      · exact fun h => dot_ext_zero fun y => by rw [dotProduct_comm]; exact LinearMap.congr_fun h y
+      intro h; rw [h]; exact LinearMap.ext (fun x => zero_dotProduct x)
+    rw [he]
+    exact (mul_le_mul_of_nonneg_right ((le_abs_self _).trans_eq (wsign_abs _))
+      (ind_nonneg _)).trans_eq (one_mul _)
+  refine half_power _ _ (?_)
+  change avg unif g^2≤_
+  rw [hh]
+  refine (avg_mono unif_law.nz hi).trans_eq ?_
+  have he : pr unif (fun x => L.mulVecLin x=0) = _ := pr_unif_lin L.mulVecLin 0
+  rw [ind_one (LinearMap.range L.mulVecLin).zero_mem,one_mul] at he
+  change pr unif _=_
+  exact he.trans (by change bp (-(L.rank:ℝ))=_; rw [show L=Mᵀ from rfl,Matrix.rank_transpose])
+
+omit [DecidableEq I] [DecidableEq J] in
+theorem flare_affine (M : Mat J J) (P : Mat J I) (k : Vec J) (a : F) (i : Vec I) :
+    let Q := fun x => dotProduct i x + (a + evmat M (P *ᵥ x+k) (P *ᵥ x+k))
+    polarize Q (pullM P P (M+Mᵀ)) := by
+  intro Q x y
+  have he : dotProduct y ((pullM P P (M+Mᵀ)) *ᵥ x)=
+      evmat M (P *ᵥ y) (P *ᵥ x) + evmat M (P *ᵥ x) (P *ᵥ y) := by
+    change evmat _ _ _=_
+    rw [evmat_pull,evmat_addM, evmat_transpose]
+  rw [he]
+  unfold Q evmat
+  simp only [dotProduct_zero,Matrix.mulVec_zero,mulVec_add,dotProduct_add,add_dotProduct,
+    zero_add]
+
+  ring_nf
+  simp only [mul_two,char_two,add_zero,zero_add]
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/QuadraticTesters.lean

@@ -1,163 +1,163 @@
-import OAI.Combinatorics.HadwigerCounterexample.MomentCoordinates
-
-namespace OAI
-
-/-! # Quadratic Testers -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Matrix
-open scoped BigOperators
-
-theorem pair_outers {I J : Type} [Fintype I] [Fintype J] (x x' : Vec I) (y y' : Vec J) :
-    mpair (vecMulVec x y) (vecMulVec x' y') =
-      dotProduct x x' * dotProduct y y' := by
-  simp only [mpair, dotProduct,vecMulVec_apply,LinearMap.coe_mk,AddHom.coe_mk,
-    Finset.sum_mul,Finset.mul_sum]
-  rw [Finset.sum_comm]
-  refine Finset.sum_congr rfl fun i _ => ?_
-  refine Finset.sum_congr rfl fun j _ => ?_
-  ring
-
-theorem mpair_sum {I J : Type} [Fintype I] [Fintype J] (m : Mat I J)
-    {α : Type*} (s : Finset α) (f : α → Mat I J) :
-    mpair (∑ i ∈ s, f i) m = ∑ i ∈ s, mpair (f i) m := by
-  rw [mpair_comm,map_sum]
-  exact Finset.sum_congr rfl fun i _ => mpair_comm _ _
-
-theorem mpair_add {I J : Type} [Fintype I] [Fintype J] (A B M : Mat I J) :
-    mpair (A+B) M = mpair A M + mpair B M := by rw [mpair_comm,map_add,mpair_comm M,mpair_comm M]
-
-theorem mpair_smul {I J : Type} [Fintype I] [Fintype J] (b : F) (A M : Mat I J) :
-    mpair (b • A) M = b * mpair A M := by rw [mpair_comm,map_smul,mpair_comm M, smul_eq_mul]
-
-variable (p : Shape)
-
-def pick (n : ℕ) (u : SelIdx p.b p.j) (d : Block p.g) (i : ℕ) : Ray p n :=
-  if h : i < n then Pi.single (u,some (d,⟨i,h⟩)) 1 else 0
-
-def readBit {n g} (z : Base g n) (d : Block g) (i : ℕ) : F :=
-  if h : i < n then z (d,⟨i,h⟩) else 0
-
-def testM (n : ℕ) (d : Block p.g) : Moment p n :=
-  ∑ i : Fin p.r, vecMulVec (pick p n emptySel d (2*i.val))
-    (pick p n emptySel d (2*i.val+1))
-
-def etab (n) (d : Block p.g) : Moment p n →ₗ[F] F := mpair (testM p n d)
-
-def test (n : ℕ) (d : Block p.g) (z z' : Base p.g n) : F :=
-  ∑ i : Fin p.r, readBit z d (2*i.val) * readBit z' d (2*i.val+1)
-
-theorem pick_point {n} (s) (z : Base p.g n) (u : SelIdx p.b p.j)
-    (d : Block p.g) (i : ℕ) :
-    dotProduct (pick p n u d i) (point p s z) = selV _ s u * readBit z d i := by
-  by_cases hi : i < n
-  · rw [pick,dite_eq_left hi,single_one_dotProduct,readBit,dite_eq_left hi]; rfl
-  · rw [pick,dite_eq_right hi,zero_dotProduct, readBit,dite_eq_right hi,mul_zero]
-
-theorem etab_point {n} (d : Block p.g) (s s') (z z' : Base p.g n) :
-    etab p n d (vecMulVec (point p s z) (point p s' z')) = test p n d z z' := by
-  unfold etab testM test
-  simp only [mpair_sum,pair_outers,pick_point]
-  simp [selV,emptySel]
-
-theorem etab_disabled {n} {l d : Tag p.g} (h : ¬allowed d l) (t : Tag p.g)
-    {m : Moment p n} (hm : m ∈ Wtag p n l) :
-    etab p n (Block.O d t) m = 0 := by
-  unfold Wtag at hm
-  induction hm using Submodule.span_induction with
-  | mem m hm =>
-    obtain ⟨s,z,hz,rfl⟩ := hm
-    rw [mom,etab_point]
-    have h' (i : ℕ) : readBit z (Block.O d t) i = 0 := by
-      simp [readBit,hz d t h]
-    simp only [test,h',mul_zero,Finset.sum_const_zero]
-  | zero => rw [map_zero]
-  | add _ _ _ _ h g => rw [map_add,h,g,add_zero]
-  | smul _ _ _ h => rw [map_smul,h,smul_zero]
-
-/-- all O testers. -/
-def etaO (n) : Moment p n →ₗ[F] F :=
-  ∑ (d : Tag p.g), ∑ (t : Tag p.g), etab p n (Block.O d t)
-
-def eta (n) : Moment p n →ₗ[F] F := etaO p n + etab p n Block.S
-
-/-- a_t read on full ambient profile using allowed tags with partner d. -/
-def roleT (n : ℕ) (t : Tag p.g) : Profile p n →ₗ[F] F :=
-  ∑ (l : Tag p.g), ∑ d ∈ Finset.univ.filter (fun d => allowed d l),
-    etab p n (Block.O d t) ∘ₗ getPair p n l d
-
-theorem roleT_cut {n} (t : Tag p.g) (w : Tag p.g → Moment p n)
-    (hw : ∀ i, w i ∈ Wtag p n i) :
-    roleT p n t (cut p n w) =
-      ∑ (l : Tag p.g), ∑ (d : Tag p.g), etab p n (Block.O d t) (w l) := by
-  simp only [roleT,LinearMap.sum_apply,LinearMap.comp_apply,getPair_cut,map_add]
-  refine Finset.sum_congr rfl fun l _ => ?_
-  rw [Finset.sum_filter]
-  refine Finset.sum_congr rfl fun d _ => ?_
-  by_cases h : allowed d l
-  · rw [ite_eq_left h,etab_disabled p (not_allowed d) t (hw d),add_zero]
-  · rw [ite_eq_right h,etab_disabled p h t (hw l)]
-
-def role (n : ℕ) := ∑ t : Tag p.g, roleT p n t
-
-theorem role_cut {n} (w : Tag p.g → Moment p n) (hw : ∀ i,w i ∈ Wtag p n i) :
-    role p n (cut p n w) = ∑ i, etaO p n (w i) := by
-  simp only [role,LinearMap.sum_apply,roleT_cut _ _ _ hw]
-  rw [Finset.sum_comm]
-  refine Finset.sum_congr rfl fun l _ => ?_
-  rw [Finset.sum_comm]
-  simp only [etaO,LinearMap.sum_apply]
-
-/-- b_t read on the full ambient profile. -/
-def sharedT (n : ℕ) (t : Tag p.g) : Profile p n →ₗ[F] F :=
-  ∑ (l : Tag p.g), etab p n Block.S ∘ₗ getPair p n l t
-
-theorem sharedT_cut {n} (hg : Odd p.g) (t : Tag p.g) (w : Tag p.g → Moment p n) :
-    sharedT p n t (cut p n w) =
-      (∑ i, etab p n Block.S (w i)) + etab p n Block.S (w t) := by
-  simp only [sharedT,LinearMap.sum_apply,LinearMap.comp_apply,getPair_cut,map_add,
-    Finset.sum_add_distrib,Finset.sum_const, Finset.card_univ]
-  simp [Tag,odd_smul_bit hg]
-
-def sharpPick (n : ℕ) (a : Fin p.b) (i : Fin n) : Ray p n :=
-  if h : 1 ≤ p.j then pick p n ⟨{a},by simp [h]⟩ Block.sharp i.val else 0
-
-def sharpM (n : ℕ) (Y : Fin p.b → Mat (Fin n) (Fin n)) : Moment p n :=
-  ∑ a : Fin p.b, ∑ i : Fin n, ∑ j : Fin n,
-    Y a i j • (vecMulVec (sharpPick p n a i) (pick p n emptySel Block.sharp j.val) +
-      vecMulVec (pick p n emptySel Block.sharp i.val) (sharpPick p n a j))
-
-theorem sharpM_point {n} (hj : 1 ≤ p.j) (Y) (s s') (z z' : Base p.g n) :
-    mpair (sharpM p n Y) (vecMulVec (point p s z) (point p s' z')) =
-      ∑ a : Fin p.b, (s a + s' a) *
-        evmat (Y a) (fun i => z (Block.sharp,i)) (fun i => z' (Block.sharp,i)) := by
-  simp only [sharpM,mpair_sum,mpair_smul,mpair_add,pair_outers,
-    sharpPick,dite_eq_left hj,pick_point,readBit,dite_eq_left (Fin.isLt _)]
-  simp [selV,emptySel,evmat,dotProduct,mulVec,Finset.mul_sum]
-  refine Finset.sum_congr rfl fun a _ => Finset.sum_congr rfl fun i _ =>
-    Finset.sum_congr rfl fun j _ => ?_
-  ring
-
-def selfM (n) (Y : Fin p.b → Mat (Fin n) (Fin n)) : Moment p n :=
-  ((∑ d : Tag p.g, ∑ t : Tag p.g, testM p n (Block.O d t)) +
-    testM p n Block.S) + sharpM p n Y
-
-theorem selfM_pair {n} (hj : 1 ≤ p.j) (Y) {m : Moment p n} (hm : m ∈ Wspace p n) :
-    mpair (selfM p n Y) m = eta p n m := by
-  unfold Wspace at hm
-  induction hm using Submodule.span_induction with
-  | mem m h =>
-    obtain ⟨s,z,rfl⟩ := h
-    simp only [selfM,mpair_sum,mpair_add,mom,sharpM_point p hj,char_two,zero_mul,
-      Finset.sum_const_zero, add_zero,eta,etaO,etab,LinearMap.add_apply,
-      LinearMap.sum_apply]
-  | zero => simp only [map_zero]
-  | add _ _ _ _ h g => rw [map_add,h,g,map_add]
-  | smul _ _ _ h => rw [map_smul,h,map_smul]
-
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.MomentCoordinates
+
+namespace OAI
+
+/-! # Quadratic Testers -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Matrix
+open scoped BigOperators
+
+theorem pair_outers {I J : Type} [Fintype I] [Fintype J] (x x' : Vec I) (y y' : Vec J) :
+    mpair (vecMulVec x y) (vecMulVec x' y') =
+      dotProduct x x' * dotProduct y y' := by
+  simp only [mpair, dotProduct,vecMulVec_apply,LinearMap.coe_mk,AddHom.coe_mk,
+    Finset.sum_mul,Finset.mul_sum]
+  rw [Finset.sum_comm]
+  refine Finset.sum_congr rfl fun i _ => ?_
+  refine Finset.sum_congr rfl fun j _ => ?_
+  ring
+
+theorem mpair_sum {I J : Type} [Fintype I] [Fintype J] (m : Mat I J)
+    {α : Type*} (s : Finset α) (f : α → Mat I J) :
+    mpair (∑ i ∈ s, f i) m = ∑ i ∈ s, mpair (f i) m := by
+  rw [mpair_comm,map_sum]
+  exact Finset.sum_congr rfl fun i _ => mpair_comm _ _
+
+theorem mpair_add {I J : Type} [Fintype I] [Fintype J] (A B M : Mat I J) :
+    mpair (A+B) M = mpair A M + mpair B M := by rw [mpair_comm,map_add,mpair_comm M,mpair_comm M]
+
+theorem mpair_smul {I J : Type} [Fintype I] [Fintype J] (b : F) (A M : Mat I J) :
+    mpair (b • A) M = b * mpair A M := by rw [mpair_comm,map_smul,mpair_comm M, smul_eq_mul]
+
+variable (p : Shape)
+
+def pick (n : ℕ) (u : SelIdx p.b p.j) (d : Block p.g) (i : ℕ) : Ray p n :=
+  if h : i < n then Pi.single (u,some (d,⟨i,h⟩)) 1 else 0
+
+def readBit {n g} (z : Base g n) (d : Block g) (i : ℕ) : F :=
+  if h : i < n then z (d,⟨i,h⟩) else 0
+
+def testM (n : ℕ) (d : Block p.g) : Moment p n :=
+  ∑ i : Fin p.r, vecMulVec (pick p n emptySel d (2*i.val))
+    (pick p n emptySel d (2*i.val+1))
+
+def etab (n) (d : Block p.g) : Moment p n →ₗ[F] F := mpair (testM p n d)
+
+def test (n : ℕ) (d : Block p.g) (z z' : Base p.g n) : F :=
+  ∑ i : Fin p.r, readBit z d (2*i.val) * readBit z' d (2*i.val+1)
+
+theorem pick_point {n} (s) (z : Base p.g n) (u : SelIdx p.b p.j)
+    (d : Block p.g) (i : ℕ) :
+    dotProduct (pick p n u d i) (point p s z) = selV _ s u * readBit z d i := by
+  by_cases hi : i < n
+  · rw [pick,dite_eq_left hi,single_one_dotProduct,readBit,dite_eq_left hi]; rfl
+  · rw [pick,dite_eq_right hi,zero_dotProduct, readBit,dite_eq_right hi,mul_zero]
+
+theorem etab_point {n} (d : Block p.g) (s s') (z z' : Base p.g n) :
+    etab p n d (vecMulVec (point p s z) (point p s' z')) = test p n d z z' := by
+  unfold etab testM test
+  simp only [mpair_sum,pair_outers,pick_point]
+  simp [selV,emptySel]
+
+theorem etab_disabled {n} {l d : Tag p.g} (h : ¬allowed d l) (t : Tag p.g)
+    {m : Moment p n} (hm : m ∈ Wtag p n l) :
+    etab p n (Block.O d t) m = 0 := by
+  unfold Wtag at hm
+  induction hm using Submodule.span_induction with
+  | mem m hm =>
+    obtain ⟨s,z,hz,rfl⟩ := hm
+    rw [mom,etab_point]
+    have h' (i : ℕ) : readBit z (Block.O d t) i = 0 := by
+      simp [readBit,hz d t h]
+    simp only [test,h',mul_zero,Finset.sum_const_zero]
+  | zero => rw [map_zero]
+  | add _ _ _ _ h g => rw [map_add,h,g,add_zero]
+  | smul _ _ _ h => rw [map_smul,h,smul_zero]
+
+/-- all O testers. -/
+def etaO (n) : Moment p n →ₗ[F] F :=
+  ∑ (d : Tag p.g), ∑ (t : Tag p.g), etab p n (Block.O d t)
+
+def eta (n) : Moment p n →ₗ[F] F := etaO p n + etab p n Block.S
+
+/-- a_t read on full ambient profile using allowed tags with partner d. -/
+def roleT (n : ℕ) (t : Tag p.g) : Profile p n →ₗ[F] F :=
+  ∑ (l : Tag p.g), ∑ d ∈ Finset.univ.filter (fun d => allowed d l),
+    etab p n (Block.O d t) ∘ₗ getPair p n l d
+
+theorem roleT_cut {n} (t : Tag p.g) (w : Tag p.g → Moment p n)
+    (hw : ∀ i, w i ∈ Wtag p n i) :
+    roleT p n t (cut p n w) =
+      ∑ (l : Tag p.g), ∑ (d : Tag p.g), etab p n (Block.O d t) (w l) := by
+  simp only [roleT,LinearMap.sum_apply,LinearMap.comp_apply,getPair_cut,map_add]
+  refine Finset.sum_congr rfl fun l _ => ?_
+  rw [Finset.sum_filter]
+  refine Finset.sum_congr rfl fun d _ => ?_
+  by_cases h : allowed d l
+  · rw [ite_eq_left h,etab_disabled p (not_allowed d) t (hw d),add_zero]
+  · rw [ite_eq_right h,etab_disabled p h t (hw l)]
+
+def role (n : ℕ) := ∑ t : Tag p.g, roleT p n t
+
+theorem role_cut {n} (w : Tag p.g → Moment p n) (hw : ∀ i,w i ∈ Wtag p n i) :
+    role p n (cut p n w) = ∑ i, etaO p n (w i) := by
+  simp only [role,LinearMap.sum_apply,roleT_cut _ _ _ hw]
+  rw [Finset.sum_comm]
+  refine Finset.sum_congr rfl fun l _ => ?_
+  rw [Finset.sum_comm]
+  simp only [etaO,LinearMap.sum_apply]
+
+/-- b_t read on the full ambient profile. -/
+def sharedT (n : ℕ) (t : Tag p.g) : Profile p n →ₗ[F] F :=
+  ∑ (l : Tag p.g), etab p n Block.S ∘ₗ getPair p n l t
+
+theorem sharedT_cut {n} (hg : Odd p.g) (t : Tag p.g) (w : Tag p.g → Moment p n) :
+    sharedT p n t (cut p n w) =
+      (∑ i, etab p n Block.S (w i)) + etab p n Block.S (w t) := by
+  simp only [sharedT,LinearMap.sum_apply,LinearMap.comp_apply,getPair_cut,map_add,
+    Finset.sum_add_distrib,Finset.sum_const, Finset.card_univ]
+  simp [Tag,odd_smul_bit hg]
+
+def sharpPick (n : ℕ) (a : Fin p.b) (i : Fin n) : Ray p n :=
+  if h : 1 ≤ p.j then pick p n ⟨{a},by simp [h]⟩ Block.sharp i.val else 0
+
+def sharpM (n : ℕ) (Y : Fin p.b → Mat (Fin n) (Fin n)) : Moment p n :=
+  ∑ a : Fin p.b, ∑ i : Fin n, ∑ j : Fin n,
+    Y a i j • (vecMulVec (sharpPick p n a i) (pick p n emptySel Block.sharp j.val) +
+      vecMulVec (pick p n emptySel Block.sharp i.val) (sharpPick p n a j))
+
+theorem sharpM_point {n} (hj : 1 ≤ p.j) (Y) (s s') (z z' : Base p.g n) :
+    mpair (sharpM p n Y) (vecMulVec (point p s z) (point p s' z')) =
+      ∑ a : Fin p.b, (s a + s' a) *
+        evmat (Y a) (fun i => z (Block.sharp,i)) (fun i => z' (Block.sharp,i)) := by
+  simp only [sharpM,mpair_sum,mpair_smul,mpair_add,pair_outers,
+    sharpPick,dite_eq_left hj,pick_point,readBit,dite_eq_left (Fin.isLt _)]
+  simp [selV,emptySel,evmat,dotProduct,mulVec,Finset.mul_sum]
+  refine Finset.sum_congr rfl fun a _ => Finset.sum_congr rfl fun i _ =>
+    Finset.sum_congr rfl fun j _ => ?_
+  ring
+
+def selfM (n) (Y : Fin p.b → Mat (Fin n) (Fin n)) : Moment p n :=
+  ((∑ d : Tag p.g, ∑ t : Tag p.g, testM p n (Block.O d t)) +
+    testM p n Block.S) + sharpM p n Y
+
+theorem selfM_pair {n} (hj : 1 ≤ p.j) (Y) {m : Moment p n} (hm : m ∈ Wspace p n) :
+    mpair (selfM p n Y) m = eta p n m := by
+  unfold Wspace at hm
+  induction hm using Submodule.span_induction with
+  | mem m h =>
+    obtain ⟨s,z,rfl⟩ := h
+    simp only [selfM,mpair_sum,mpair_add,mom,sharpM_point p hj,char_two,zero_mul,
+      Finset.sum_const_zero, add_zero,eta,etaO,etab,LinearMap.add_apply,
+      LinearMap.sum_apply]
+  | zero => simp only [map_zero]
+  | add _ _ _ _ h g => rw [map_add,h,g,map_add]
+  | smul _ _ _ h => rw [map_smul,h,map_smul]
+
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/QueryConcentration.lean

@@ -1,172 +1,172 @@
-import OAI.Combinatorics.HadwigerCounterexample.GroupedQueryIndependence
-
-namespace OAI
-
-/-! # Query Concentration -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Module Matrix Finset Function
-open scoped BigOperators
-variable {p : Shape} {n N : ℕ} {I G A K D : Type} [Fintype I] [Fintype G] [Fintype A]
-variable [Fintype K] [Fintype D] [DecidableEq I] [DecidableEq G] [DecidableEq K]
-
-structure Program (p : Shape) (n : ℕ) {I G : Type} (g : Route I G) (A : Type) where
-  left : A→NomQuery p n g
-  right : A→NomQuery p n g
-
-variable {g : Route I G}
-
-namespace Program
-variable (s : Program p n g A)
-
-def free (x : K→ A) :=
-  (∀ i,Injective (pooled (s.left ∘ x) i).mulVec)∧
-  (∀ i,Injective (pooled (s.right ∘ x) i).mulVec)
-
-def showKey (x : A) (o : Forum p n N G) :=
-  peekR p g (s.left x) (s.right x) o
-
-def oexpect (w : Wgt A) (F : A → Rack I N → ℝ) (o : Forum p n N G) :=
-  avg w (fun x => F x (s.showKey x o))
-end Program
-
-theorem forum_law (m : Mixer p n) {N : ℕ} (hN : 2*num (Full p n)<N) :
-    IsLaw (forumLaw m N (G:=G)) :=
-  prodW_law (fun _ => unifOn_law (framesAt_exists (gramCond_exists m)
-    (by rw [←two_mul]; simpa only [num,Fintype.card_fin] using hN)))
-
-theorem avg_bound1 {w : Wgt A} (hw : IsLaw w) (f : Wgt A) (hf : ∀ x,|f x|≤1) :
-    |avg w f|≤1 := (abs_avg_le hw.nz).trans (hw.avg_le hf)
-theorem avg_cross_sq (w : Wgt A) (f : Wgt A) :
-    avg w f ^ 2=avg (draws Bool w) (fun q => f (q true)* f (q false)) := by
-  let g (i : Bool) := f
-  have hh := prodW_avg (fun _ : Bool => w) g
-  have he : prodW g=(fun q => f (q true)* f (q false)) := by ext; unfold prodW; rw [Fintype.prod_bool]
-  rw [he,Fintype.prod_bool] at hh; rw [pow_two]; exact hh.symm
-
-theorem avg_var (w : Wgt A) (f : Wgt A) (hw : IsLaw w) :
-    avg w (fun x => (f x-avg w f)^2) = avg w (fun x => f x^2) - (avg w f)^2 := by
-  let g := avg w f
-  have hh (x) : (f x-g)^2=f x^2-2*g*f x+g^2 := by ring
-  change avg w (fun x => (f x-g)^2)=_
-  simp_rw [hh,avg_add,avg_sub,avg_mul',hw.avg_const]
-  unfold g; ring
-
-namespace Program
-variable {s : Program p n g A}
-
-set_option maxHeartbeats 800000 in
-theorem oVar (m : Mixer p n) (hN : 2*num (Full p n) < N)
-    (T : A→Wgt (Rack I N))
-    (w : Wgt A) (hw : IsLaw w) (hT : ∀ i x,|T i x|≤1)
-    (k : ℝ) (hk : ∀ i,num (Port (tied g Bool) i)≤k)
-    (hK : 2*k-N≤-1)
-    (r : ℝ) (hr : pr (draws Bool w) (fun x => ¬ s.free x) ≤ r) :
-    let v := forumLaw (G:=G) m N
-    let f := s.oexpect w T
-    avg v (fun o => (f o-avg v f)^2) ≤
-      2*r + 2*netFact (tied g Bool)*twinkle (tied g Bool) k N := by
-  classical
-  let v := forumLaw (G:=G) m N
-  let f := s.oexpect w T
-  let F (x : A) := fun o => T x (s.showKey x o)
-  let D := draws Bool w
-  let B := 2*netFact (tied g Bool)*twinkle (tied g Bool) k N
-  have hD : IsLaw D := draws_law hw
-  have hv : IsLaw v := forum_law _ hN
-  let V (x : Bool→A) := avg v (fun o => F (x true) o * F (x false) o)
-  let W (x : Bool→A) := avg v (F (x true))*avg v (F (x false))
-  have hW :
-      (avg v f)^2 = avg D W := by
-    unfold f oexpect
-    rw [avg_avg,avg_cross_sq]
-  have hV :
-      avg v (fun x => f x^2) = avg D V := by
-    unfold f oexpect; simp_rw [avg_cross_sq]; rw [avg_avg]
-  have hi x :
-      V x-W x ≤ 2*ind (¬s.free x)+B := by
-    by_cases he : s.free x
-    · have hh := pooled_batch (s.left ∘ x) (s.right ∘ x) m hN k hk hK he.1 he.2
-        (T ∘ x) (fun i y => hT _ _)
-      simp_rw [Fintype.prod_bool] at hh
-      rw [ind_zero (fun h => h he),mul_zero,zero_add]
-      exact (le_abs_self _).trans hh
-    have h1 (a b : ℝ) (h : |a|≤1) (g : |b|≤1) : |a*b|≤1 := by
-      rw [abs_mul]
-      exact (mul_le_mul h g (abs_nonneg _) zero_le_one).trans_eq (by ring)
-    have hh : |W x|≤1 := h1 _ _ (avg_bound1 hv _ (fun y => hT _ _)) (avg_bound1 hv _
-      (fun y => hT _ _))
-    have hg : |V x|≤1 := avg_bound1 hv _ (fun i => h1 _ _ (hT _ _) (hT _ _))
-    have ht : 0 ≤ twinkle (tied g Bool) k N := add_nonneg (mul_nonneg (Nat.cast_nonneg _)
-      (mul_nonneg (by norm_num) (bp_pos _).le)) (bp_pos _).le
-    have h2 : 0 ≤ B := mul_nonneg (mul_nonneg (by norm_num) netFact_pos.le) ht
-    rw [ind_one he,mul_one]
-    exact sub_le_iff_le_add.mpr (by linarith [(abs_le.mp hh).1,(abs_le.mp hg).2])
-  change avg v _ ≤ _
-  rw [avg_var v f hv,hW,hV,← avg_sub]
-  apply (avg_mono hD.nz hi).trans
-  rw [avg_add,avg_mul',hD.avg_const]
-  exact add_le_add_left (mul_le_mul_of_nonneg_left hr (by norm_num)) _
-
-def oFreq (w : Wgt A) (F : A → Rack I N→Prop) (o : Forum p n N G)
-    (s : Program p n g A) :=
-  pr w (fun i => F i (s.showKey i o))
-
-set_option maxHeartbeats 800000 in
-theorem oTail (m : Mixer p n) (hN : 2*num (Full p n) < N)
-    (T : A→Rack I N →Prop)
-    (w : Wgt A) (hw : IsLaw w)
-    {k : ℝ} {l : ℕ} (hk : ∀ i,num (Port (tied g (Fin l)) i)≤k)
-    (hK : 2*k-N≤-1)
-    (r : ℝ) (hr : pr (draws (Fin l) w) (fun x => ¬ s.free x) ≤ r)
-    {ε : ℝ} (hε : 0 ≤ ε) :
-    let v := forumLaw (G:=G) m N
-    let f := (fun o => oFreq w T o s)
-    (ε^l - r)*pr v (fun x => ε ≤ f x) ≤ netFact (tied g (Fin l))* (avg v f)^l := by
-  classical
-  let v := forumLaw (G:=G) m N
-  let f := (fun o : Forum p n N G => oFreq w T o s)
-  have hv : IsLaw v := forum_law _ hN
-  let F := draws (Fin l) w
-  have hF : IsLaw F := draws_law hw
-  let P (x) (y : Fin l→A) := ∀ i,T (y i) (s.showKey (y i) x)
-  have hh (x) : pr F (fun y => P x y)= f x ^ l := by
-    unfold P F draws
-    rw [prodW_pr (fun (_ : Fin l) => w) (fun _ i => T i (s.showKey i x))]
-    simp only [Finset.prod_const, Finset.card_univ,Fintype.card_fin]
-    rfl
-  let Q (x : Fin l → A) := s.free x
-  let S (o) (x : Fin l→A) := P o x ∧ Q x
-  have hi (o) :
-      (ε^l-r)*ind (ε≤f o)≤ pr F (S o) := by
-    by_cases ht : ε≤f o
-    · rw [ind_one ht,mul_one]
-      refine (sub_le_sub (pow_le_pow_left₀ hε ht l) hr).trans ?_
-      rw [←hh]; exact pr_shield hF.nz _ _
-    rw [ind_zero ht,mul_zero]; exact pr_nonneg hF.nz
-  let W (x) := pr v (fun i => T x (s.showKey x i))
-  let C := netFact (tied g (Fin l))
-  have hq (x : Fin l → A) :
-      pr v (fun i => S i x) ≤ C*∏ i:Fin l,W (x i) := by
-    by_cases he : Q x
-    · have hg := pool_upper (s.left ∘ x) (s.right ∘ x) m hN he.1 he.2
-        (fun i => by linarith only [hk i,hK]) (T ∘ x)
-      simp only [S,he,and_true]
-      exact hg
-    simp only [S,he,and_false,pr_false]; exact mul_nonneg netFact_pos.le
-      (Finset.prod_nonneg fun i _ => pr_nonneg hv.nz)
-  have hg : avg v f=avg w W := avg_avg _ _ _
-  have he := avg_mono hv.nz hi
-  rw [avg_mul'] at he
-  change _ ≤ _
-  apply le_trans he
-  calc avg v (fun x => pr F (S x)) = avg F (fun y => pr v (fun x => S x y)) := avg_avg _ _ _
-       _ ≤ avg F (fun x => C*∏ i,W (x i)) := avg_mono hF.nz hq
-       _ = netFact _ * (avg v f)^l := by rw [avg_mul',hg, poweravg]
-end Program
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.GroupedQueryIndependence
+
+namespace OAI
+
+/-! # Query Concentration -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Module Matrix Finset Function
+open scoped BigOperators
+variable {p : Shape} {n N : ℕ} {I G A K D : Type} [Fintype I] [Fintype G] [Fintype A]
+variable [Fintype K] [Fintype D] [DecidableEq I] [DecidableEq G] [DecidableEq K]
+
+structure Program (p : Shape) (n : ℕ) {I G : Type} (g : Route I G) (A : Type) where
+  left : A→NomQuery p n g
+  right : A→NomQuery p n g
+
+variable {g : Route I G}
+
+namespace Program
+variable (s : Program p n g A)
+
+def free (x : K→ A) :=
+  (∀ i,Injective (pooled (s.left ∘ x) i).mulVec)∧
+  (∀ i,Injective (pooled (s.right ∘ x) i).mulVec)
+
+def showKey (x : A) (o : Forum p n N G) :=
+  peekR p g (s.left x) (s.right x) o
+
+def oexpect (w : Wgt A) (F : A → Rack I N → ℝ) (o : Forum p n N G) :=
+  avg w (fun x => F x (s.showKey x o))
+end Program
+
+theorem forum_law (m : Mixer p n) {N : ℕ} (hN : 2*num (Full p n)<N) :
+    IsLaw (forumLaw m N (G:=G)) :=
+  prodW_law (fun _ => unifOn_law (framesAt_exists (gramCond_exists m)
+    (by rw [←two_mul]; simpa only [num,Fintype.card_fin] using hN)))
+
+theorem avg_bound1 {w : Wgt A} (hw : IsLaw w) (f : Wgt A) (hf : ∀ x,|f x|≤1) :
+    |avg w f|≤1 := (abs_avg_le hw.nz).trans (hw.avg_le hf)
+theorem avg_cross_sq (w : Wgt A) (f : Wgt A) :
+    avg w f ^ 2=avg (draws Bool w) (fun q => f (q true)* f (q false)) := by
+  let g (i : Bool) := f
+  have hh := prodW_avg (fun _ : Bool => w) g
+  have he : prodW g=(fun q => f (q true)* f (q false)) := by ext; unfold prodW; rw [Fintype.prod_bool]
+  rw [he,Fintype.prod_bool] at hh; rw [pow_two]; exact hh.symm
+
+theorem avg_var (w : Wgt A) (f : Wgt A) (hw : IsLaw w) :
+    avg w (fun x => (f x-avg w f)^2) = avg w (fun x => f x^2) - (avg w f)^2 := by
+  let g := avg w f
+  have hh (x) : (f x-g)^2=f x^2-2*g*f x+g^2 := by ring
+  change avg w (fun x => (f x-g)^2)=_
+  simp_rw [hh,avg_add,avg_sub,avg_mul',hw.avg_const]
+  unfold g; ring
+
+namespace Program
+variable {s : Program p n g A}
+
+set_option maxHeartbeats 800000 in
+theorem oVar (m : Mixer p n) (hN : 2*num (Full p n) < N)
+    (T : A→Wgt (Rack I N))
+    (w : Wgt A) (hw : IsLaw w) (hT : ∀ i x,|T i x|≤1)
+    (k : ℝ) (hk : ∀ i,num (Port (tied g Bool) i)≤k)
+    (hK : 2*k-N≤-1)
+    (r : ℝ) (hr : pr (draws Bool w) (fun x => ¬ s.free x) ≤ r) :
+    let v := forumLaw (G:=G) m N
+    let f := s.oexpect w T
+    avg v (fun o => (f o-avg v f)^2) ≤
+      2*r + 2*netFact (tied g Bool)*twinkle (tied g Bool) k N := by
+  classical
+  let v := forumLaw (G:=G) m N
+  let f := s.oexpect w T
+  let F (x : A) := fun o => T x (s.showKey x o)
+  let D := draws Bool w
+  let B := 2*netFact (tied g Bool)*twinkle (tied g Bool) k N
+  have hD : IsLaw D := draws_law hw
+  have hv : IsLaw v := forum_law _ hN
+  let V (x : Bool→A) := avg v (fun o => F (x true) o * F (x false) o)
+  let W (x : Bool→A) := avg v (F (x true))*avg v (F (x false))
+  have hW :
+      (avg v f)^2 = avg D W := by
+    unfold f oexpect
+    rw [avg_avg,avg_cross_sq]
+  have hV :
+      avg v (fun x => f x^2) = avg D V := by
+    unfold f oexpect; simp_rw [avg_cross_sq]; rw [avg_avg]
+  have hi x :
+      V x-W x ≤ 2*ind (¬s.free x)+B := by
+    by_cases he : s.free x
+    · have hh := pooled_batch (s.left ∘ x) (s.right ∘ x) m hN k hk hK he.1 he.2
+        (T ∘ x) (fun i y => hT _ _)
+      simp_rw [Fintype.prod_bool] at hh
+      rw [ind_zero (fun h => h he),mul_zero,zero_add]
+      exact (le_abs_self _).trans hh
+    have h1 (a b : ℝ) (h : |a|≤1) (g : |b|≤1) : |a*b|≤1 := by
+      rw [abs_mul]
+      exact (mul_le_mul h g (abs_nonneg _) zero_le_one).trans_eq (by ring)
+    have hh : |W x|≤1 := h1 _ _ (avg_bound1 hv _ (fun y => hT _ _)) (avg_bound1 hv _
+      (fun y => hT _ _))
+    have hg : |V x|≤1 := avg_bound1 hv _ (fun i => h1 _ _ (hT _ _) (hT _ _))
+    have ht : 0 ≤ twinkle (tied g Bool) k N := add_nonneg (mul_nonneg (Nat.cast_nonneg _)
+      (mul_nonneg (by norm_num) (bp_pos _).le)) (bp_pos _).le
+    have h2 : 0 ≤ B := mul_nonneg (mul_nonneg (by norm_num) netFact_pos.le) ht
+    rw [ind_one he,mul_one]
+    exact sub_le_iff_le_add.mpr (by linarith [(abs_le.mp hh).1,(abs_le.mp hg).2])
+  change avg v _ ≤ _
+  rw [avg_var v f hv,hW,hV,← avg_sub]
+  apply (avg_mono hD.nz hi).trans
+  rw [avg_add,avg_mul',hD.avg_const]
+  exact add_le_add_left (mul_le_mul_of_nonneg_left hr (by norm_num)) _
+
+def oFreq (w : Wgt A) (F : A → Rack I N→Prop) (o : Forum p n N G)
+    (s : Program p n g A) :=
+  pr w (fun i => F i (s.showKey i o))
+
+set_option maxHeartbeats 800000 in
+theorem oTail (m : Mixer p n) (hN : 2*num (Full p n) < N)
+    (T : A→Rack I N →Prop)
+    (w : Wgt A) (hw : IsLaw w)
+    {k : ℝ} {l : ℕ} (hk : ∀ i,num (Port (tied g (Fin l)) i)≤k)
+    (hK : 2*k-N≤-1)
+    (r : ℝ) (hr : pr (draws (Fin l) w) (fun x => ¬ s.free x) ≤ r)
+    {ε : ℝ} (hε : 0 ≤ ε) :
+    let v := forumLaw (G:=G) m N
+    let f := (fun o => oFreq w T o s)
+    (ε^l - r)*pr v (fun x => ε ≤ f x) ≤ netFact (tied g (Fin l))* (avg v f)^l := by
+  classical
+  let v := forumLaw (G:=G) m N
+  let f := (fun o : Forum p n N G => oFreq w T o s)
+  have hv : IsLaw v := forum_law _ hN
+  let F := draws (Fin l) w
+  have hF : IsLaw F := draws_law hw
+  let P (x) (y : Fin l→A) := ∀ i,T (y i) (s.showKey (y i) x)
+  have hh (x) : pr F (fun y => P x y)= f x ^ l := by
+    unfold P F draws
+    rw [prodW_pr (fun (_ : Fin l) => w) (fun _ i => T i (s.showKey i x))]
+    simp only [Finset.prod_const, Finset.card_univ,Fintype.card_fin]
+    rfl
+  let Q (x : Fin l → A) := s.free x
+  let S (o) (x : Fin l→A) := P o x ∧ Q x
+  have hi (o) :
+      (ε^l-r)*ind (ε≤f o)≤ pr F (S o) := by
+    by_cases ht : ε≤f o
+    · rw [ind_one ht,mul_one]
+      refine (sub_le_sub (pow_le_pow_left₀ hε ht l) hr).trans ?_
+      rw [←hh]; exact pr_shield hF.nz _ _
+    rw [ind_zero ht,mul_zero]; exact pr_nonneg hF.nz
+  let W (x) := pr v (fun i => T x (s.showKey x i))
+  let C := netFact (tied g (Fin l))
+  have hq (x : Fin l → A) :
+      pr v (fun i => S i x) ≤ C*∏ i:Fin l,W (x i) := by
+    by_cases he : Q x
+    · have hg := pool_upper (s.left ∘ x) (s.right ∘ x) m hN he.1 he.2
+        (fun i => by linarith only [hk i,hK]) (T ∘ x)
+      simp only [S,he,and_true]
+      exact hg
+    simp only [S,he,and_false,pr_false]; exact mul_nonneg netFact_pos.le
+      (Finset.prod_nonneg fun i _ => pr_nonneg hv.nz)
+  have hg : avg v f=avg w W := avg_avg _ _ _
+  have he := avg_mono hv.nz hi
+  rw [avg_mul'] at he
+  change _ ≤ _
+  apply le_trans he
+  calc avg v (fun x => pr F (S x)) = avg F (fun y => pr v (fun x => S x y)) := avg_avg _ _ _
+       _ ≤ avg F (fun x => C*∏ i,W (x i)) := avg_mono hF.nz hq
+       _ = netFact _ * (avg v f)^l := by rw [avg_mul',hg, poweravg]
+end Program
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/RandomBinaryMixing.lean

@@ -1,120 +1,120 @@
-import OAI.Combinatorics.HadwigerCounterexample.BinaryEvaluationForms
-
-namespace OAI
-
-/-! # Random Binary Mixing -/
-
-noncomputable section
-namespace HadwigerCounterexample
-
-instance momFintype (p : Shape) (n : ℕ) : Fintype (Moment p n) := inferInstance
-instance idxDec (p : Shape) : DecidableEq (MIdx p) := inferInstance
-instance arrFintype (p : Shape) (n : ℕ) : Fintype (MArr p n) := inferInstance
-instance drawFintype (p : Shape) (n : ℕ) : Fintype (Draw p n) := inferInstance
-
-open Filter Matrix Function
-open scoped BigOperators Topology
-
-variable {p : Shape} {n : ℕ}
-
-theorem rank_fifth_bound (m n : ℕ) (hm : n/2≤m) (hn : 100 ≤ n) :
-    pr unif (fun M : Mat (Fin m) (Fin m) => 5*M.rank<n) ≤ bp (- (n:ℝ)) := by
-  apply le_trans (pr_mono unif_law.nz (q:=fun M => M.rank≤ n/5) (fun M h => by omega))
-  refine (pr_matrix_rank _).trans ?_
-  apply bp_le
-  simp only [num,Fintype.card_fin]
-  let r := n/5
-  have h1 : 5*r≤n := by unfold r; omega
-  have h2 : n≤2*m+1 := by omega
-  have h3 : 45≤m := by omega
-  have hi : (m+m)*r+n≤m*m := by
-    nlinarith only [h1,h2,h3,
-      Nat.mul_le_mul_left m h1,Nat.mul_le_mul_left m h2,Nat.mul_le_mul_left m h3]
-  have hh : ((m:ℝ)+m)*r+n ≤ m*(m:ℝ) := by exact_mod_cast hi
-  unfold r at hh; linarith only [hh]
-
-theorem pr_surj_rank {m} (hn : 100≤n) (hm : n/2≤m)
-    (A : Draw p n →ₗ[F] Mat (Fin m) (Fin m))
-    (h : Function.Surjective A) :
-    pr unif (fun x => 5*(A x).rank < n) ≤ bp (- (n:ℝ)) := by
-  classical
-  have he := mapW_pr unif A (fun x => 5*x.rank<n)
-  rw [map_unif_surjective A h] at he
-  exact he.symm.le.trans (rank_fifth_bound m n hm hn)
-
-theorem ztest_prob (p : Shape) (s t : Label p.b) (hj : 1≤p.j)
-    (c : Vec (MBits p)) (b : Vec Bool) (hn : 100≤n) :
-    pr unif (fun x : Draw p n => s ≠ t ∧ c≠0 ∧
-      5*blockRank Block.Z s t (indexedSum (drawn x) c+selfSum (drawn x) b)<n)
-      ≤ bp (- (n:ℝ)) := by
-  classical
-  by_cases h : s≠t ∧ c≠0
-  · simp only [← and_assoc (a:=s≠t),blockRank,map_add,obsZ_self,add_zero]
-    refine le_trans (pr_mono unif_law.nz ?_) (pr_surj_rank hn (by omega) (obsZ p n s t c) (obsZ_surj _ _ hj h.1 h.2))
-    exact fun x hx => hx.2
-  simp_rw [← and_assoc (a:=s≠t),h,false_and,pr_false]
-  exact (bp_pos _).le
-
-theorem stest_prob (p : Shape) (s t : Label p.b) (hj : 1≤p.j)
-    (b : Vec Bool) (hn : 100≤n) :
-    pr unif (fun x : Draw p n => s ≠ t ∧ b≠0 ∧
-      5*blockRank Block.sharp s t (selfSum (drawn x) b)<n)
-      ≤ bp (- (n:ℝ)) := by
-  classical
-  by_cases h : s≠t ∧ b≠0
-  · simp only [← and_assoc (a:=s≠t),blockRank,pull_selfPart _ _ hj]
-    let l := Fin.castLE (show n/2≤n by omega)
-    let r (i : Fin (n/2)) : Fin n := ⟨n/2+i.val,by have := i.isLt; omega⟩
-    have he : Function.Surjective (obsHalf p s t b n l r) := by
-      refine obsHalf_surj _ _ h.1 h.2 _ (Fin.castLE_injective _) (fun i j h => ?_) ?_
-      · exact Fin.ext (Nat.add_left_cancel (congrArg Fin.val h))
-      intro i j h
-      have he : i.val = n/2+j.val := congrArg Fin.val h
-      have hg := i.isLt; omega
-    apply le_trans _ (pr_surj_rank hn (by omega) (obsHalf p s t b n l r) he)
-    refine pr_mono unif_law.nz fun x hx => lt_of_le_of_lt ?_ hx.2
-    exact Nat.mul_le_mul_left _ ((selfPartial (p:=p) s t b x).rank_submatrix_le l r)
-  simp_rw [← and_assoc (a:=s≠t),h,false_and,pr_false]
-  exact (bp_pos _).le
-
-theorem binary_likely (p : Shape) (hj : 1≤p.j) :
-    ∀ᶠ n : ℕ in atTop,
-      pr unif (fun x : Draw p n => ¬binaryGood (drawn x)) < 1/4 := by
-  classical
-  let I := Label p.b × Label p.b × Vec (MBits p) × Vec Bool
-  let J := Label p.b × Label p.b × Vec Bool
-  let T := I⊕J
-  let m := num T
-  have h : Tendsto (fun n:ℕ=>m*bp (- (n:ℝ))) atTop (𝓝 0) := by
-    have h : Tendsto (fun n:ℕ=>bp (-(1:ℝ)*(n:ℝ))) atTop (𝓝 0) :=
-      (bp_tendsto_zero zero_lt_one).comp tendsto_natCast_atTop_atTop
-    simpa using h.const_mul m
-  filter_upwards [h.eventually (gt_mem_nhds (show (0:ℝ)<1/4 by norm_num)),
-    eventually_ge_atTop 100] with n hn hg
-  let bad (i : T) (x : Draw p n) :=
-    match i with
-    | .inl (s,t,c,b) => s≠t ∧ c≠0 ∧ 5*blockRank Block.Z s t
-        (indexedSum (drawn x) c+selfSum (drawn x) b)<n
-    | .inr (s,t,b) => s≠t ∧ b≠0 ∧ 5*blockRank Block.sharp s t (selfSum (drawn x) b)<n
-  have he (i : T) : pr unif (bad i) ≤ bp (- (n:ℝ)) := by
-    rcases i with ⟨s,t,c,b⟩|⟨s,t,b⟩
-    · exact ztest_prob _ _ _ hj _ _ hg
-    exact stest_prob _ _ _ hj _ hg
-  have hi : pr unif (fun x => ∃ i, bad i x) ≤ m*bp (- (n:ℝ)) :=
-    (pr_exists_le unif_law.nz bad).trans ((Finset.sum_le_sum (fun i _ => he i)).trans_eq (by
-      rw [Finset.sum_const, Finset.card_univ,nsmul_eq_mul]))
-  apply lt_of_le_of_lt (le_trans (pr_mono unif_law.nz ?_) hi) hn
-  intro x hx
-  by_contra! H
-  apply hx
-  intro s t hst
-  constructor
-  · intro c b hc
-    exact le_of_not_gt fun e => H (Sum.inl (s,t,c,b)) ⟨hst,hc,e⟩
-  intro b hb
-  exact le_of_not_gt fun e => H (Sum.inr (s,t,b)) ⟨hst,hb,e⟩
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.BinaryEvaluationForms
+
+namespace OAI
+
+/-! # Random Binary Mixing -/
+
+noncomputable section
+namespace HadwigerCounterexample
+
+instance momFintype (p : Shape) (n : ℕ) : Fintype (Moment p n) := inferInstance
+instance idxDec (p : Shape) : DecidableEq (MIdx p) := inferInstance
+instance arrFintype (p : Shape) (n : ℕ) : Fintype (MArr p n) := inferInstance
+instance drawFintype (p : Shape) (n : ℕ) : Fintype (Draw p n) := inferInstance
+
+open Filter Matrix Function
+open scoped BigOperators Topology
+
+variable {p : Shape} {n : ℕ}
+
+theorem rank_fifth_bound (m n : ℕ) (hm : n/2≤m) (hn : 100 ≤ n) :
+    pr unif (fun M : Mat (Fin m) (Fin m) => 5*M.rank<n) ≤ bp (- (n:ℝ)) := by
+  apply le_trans (pr_mono unif_law.nz (q:=fun M => M.rank≤ n/5) (fun M h => by omega))
+  refine (pr_matrix_rank _).trans ?_
+  apply bp_le
+  simp only [num,Fintype.card_fin]
+  let r := n/5
+  have h1 : 5*r≤n := by unfold r; omega
+  have h2 : n≤2*m+1 := by omega
+  have h3 : 45≤m := by omega
+  have hi : (m+m)*r+n≤m*m := by
+    nlinarith only [h1,h2,h3,
+      Nat.mul_le_mul_left m h1,Nat.mul_le_mul_left m h2,Nat.mul_le_mul_left m h3]
+  have hh : ((m:ℝ)+m)*r+n ≤ m*(m:ℝ) := by exact_mod_cast hi
+  unfold r at hh; linarith only [hh]
+
+theorem pr_surj_rank {m} (hn : 100≤n) (hm : n/2≤m)
+    (A : Draw p n →ₗ[F] Mat (Fin m) (Fin m))
+    (h : Function.Surjective A) :
+    pr unif (fun x => 5*(A x).rank < n) ≤ bp (- (n:ℝ)) := by
+  classical
+  have he := mapW_pr unif A (fun x => 5*x.rank<n)
+  rw [map_unif_surjective A h] at he
+  exact he.symm.le.trans (rank_fifth_bound m n hm hn)
+
+theorem ztest_prob (p : Shape) (s t : Label p.b) (hj : 1≤p.j)
+    (c : Vec (MBits p)) (b : Vec Bool) (hn : 100≤n) :
+    pr unif (fun x : Draw p n => s ≠ t ∧ c≠0 ∧
+      5*blockRank Block.Z s t (indexedSum (drawn x) c+selfSum (drawn x) b)<n)
+      ≤ bp (- (n:ℝ)) := by
+  classical
+  by_cases h : s≠t ∧ c≠0
+  · simp only [← and_assoc (a:=s≠t),blockRank,map_add,obsZ_self,add_zero]
+    refine le_trans (pr_mono unif_law.nz ?_) (pr_surj_rank hn (by omega) (obsZ p n s t c) (obsZ_surj _ _ hj h.1 h.2))
+    exact fun x hx => hx.2
+  simp_rw [← and_assoc (a:=s≠t),h,false_and,pr_false]
+  exact (bp_pos _).le
+
+theorem stest_prob (p : Shape) (s t : Label p.b) (hj : 1≤p.j)
+    (b : Vec Bool) (hn : 100≤n) :
+    pr unif (fun x : Draw p n => s ≠ t ∧ b≠0 ∧
+      5*blockRank Block.sharp s t (selfSum (drawn x) b)<n)
+      ≤ bp (- (n:ℝ)) := by
+  classical
+  by_cases h : s≠t ∧ b≠0
+  · simp only [← and_assoc (a:=s≠t),blockRank,pull_selfPart _ _ hj]
+    let l := Fin.castLE (show n/2≤n by omega)
+    let r (i : Fin (n/2)) : Fin n := ⟨n/2+i.val,by have := i.isLt; omega⟩
+    have he : Function.Surjective (obsHalf p s t b n l r) := by
+      refine obsHalf_surj _ _ h.1 h.2 _ (Fin.castLE_injective _) (fun i j h => ?_) ?_
+      · exact Fin.ext (Nat.add_left_cancel (congrArg Fin.val h))
+      intro i j h
+      have he : i.val = n/2+j.val := congrArg Fin.val h
+      have hg := i.isLt; omega
+    apply le_trans _ (pr_surj_rank hn (by omega) (obsHalf p s t b n l r) he)
+    refine pr_mono unif_law.nz fun x hx => lt_of_le_of_lt ?_ hx.2
+    exact Nat.mul_le_mul_left _ ((selfPartial (p:=p) s t b x).rank_submatrix_le l r)
+  simp_rw [← and_assoc (a:=s≠t),h,false_and,pr_false]
+  exact (bp_pos _).le
+
+theorem binary_likely (p : Shape) (hj : 1≤p.j) :
+    ∀ᶠ n : ℕ in atTop,
+      pr unif (fun x : Draw p n => ¬binaryGood (drawn x)) < 1/4 := by
+  classical
+  let I := Label p.b × Label p.b × Vec (MBits p) × Vec Bool
+  let J := Label p.b × Label p.b × Vec Bool
+  let T := I⊕J
+  let m := num T
+  have h : Tendsto (fun n:ℕ=>m*bp (- (n:ℝ))) atTop (𝓝 0) := by
+    have h : Tendsto (fun n:ℕ=>bp (-(1:ℝ)*(n:ℝ))) atTop (𝓝 0) :=
+      (bp_tendsto_zero zero_lt_one).comp tendsto_natCast_atTop_atTop
+    simpa using h.const_mul m
+  filter_upwards [h.eventually (gt_mem_nhds (show (0:ℝ)<1/4 by norm_num)),
+    eventually_ge_atTop 100] with n hn hg
+  let bad (i : T) (x : Draw p n) :=
+    match i with
+    | .inl (s,t,c,b) => s≠t ∧ c≠0 ∧ 5*blockRank Block.Z s t
+        (indexedSum (drawn x) c+selfSum (drawn x) b)<n
+    | .inr (s,t,b) => s≠t ∧ b≠0 ∧ 5*blockRank Block.sharp s t (selfSum (drawn x) b)<n
+  have he (i : T) : pr unif (bad i) ≤ bp (- (n:ℝ)) := by
+    rcases i with ⟨s,t,c,b⟩|⟨s,t,b⟩
+    · exact ztest_prob _ _ _ hj _ _ hg
+    exact stest_prob _ _ _ hj _ hg
+  have hi : pr unif (fun x => ∃ i, bad i x) ≤ m*bp (- (n:ℝ)) :=
+    (pr_exists_le unif_law.nz bad).trans ((Finset.sum_le_sum (fun i _ => he i)).trans_eq (by
+      rw [Finset.sum_const, Finset.card_univ,nsmul_eq_mul]))
+  apply lt_of_le_of_lt (le_trans (pr_mono unif_law.nz ?_) hi) hn
+  intro x hx
+  by_contra! H
+  apply hx
+  intro s t hst
+  constructor
+  · intro c b hc
+    exact le_of_not_gt fun e => H (Sum.inl (s,t,c,b)) ⟨hst,hc,e⟩
+  intro b hb
+  exact le_of_not_gt fun e => H (Sum.inr (s,t,b)) ⟨hst,hb,e⟩
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/RandomLinearTransforms.lean

@@ -1,141 +1,141 @@
-import OAI.Combinatorics.HadwigerCounterexample.FrameRotations
-
-namespace OAI
-
-/-! # Random Linear Transforms -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Matrix Module LinearMap Submodule Finset Function
-open scoped BigOperators
-variable {I J K : Type} [Fintype I] [DecidableEq I] [Fintype J] [DecidableEq J]
-    [Fintype K] [DecidableEq K]
-
-namespace Move
-
-instance finiteMove (I : Type) [Fintype I] [DecidableEq I] : Fintype (Move I) := by
-  classical
-  let S := { z : Mat I I × Mat I I // z.1*z.2 = 1 ∧ z.2*z.1=1}
-  let e : S ≃ Move I := {
-    toFun z := ⟨z.val.1,z.val.2,z.property.1,z.property.2⟩
-    invFun z := ⟨(z.L,z.R),z.LR,z.RL⟩
-    left_inv _ := rfl
-    right_inv _ := rfl }
-  exact Fintype.ofEquiv S e
-
-instance identity_move (I : Type) [Fintype I] [DecidableEq I] : Nonempty (Move I) :=
-  ⟨1,1, Matrix.one_mul _,Matrix.mul_one _⟩
-def combine (c d : Move I) : Move I :=
-  ⟨c.L*d.L,d.R*c.R,by rw [Matrix.mul_assoc,←Matrix.mul_assoc d.L,d.LR,Matrix.one_mul,c.LR],
-    by rw [Matrix.mul_assoc,←Matrix.mul_assoc c.R,c.RL,Matrix.one_mul,d.RL]⟩
-
-@[ext] theorem extn (p q : Move I) (h : p.L=q.L) (h' : p.R=q.R) : p=q := by
-  cases p; cases q; cases h; cases h'; rfl
-def circShift (c : Move I) : Move I≃ Move I where
-  toFun := combine c
-  invFun := combine c.sym
-  left_inv d := extn _ _ (by simp only [combine,sym,←Matrix.mul_assoc,c.RL, Matrix.one_mul])
-    (by simp only [combine,sym,Matrix.mul_assoc,c.RL, Matrix.mul_one])
-  right_inv d := extn _ _ (by simp only [combine,sym,←Matrix.mul_assoc,c.LR, Matrix.one_mul])
-    (by simp only [combine,sym,Matrix.mul_assoc,c.LR, Matrix.mul_one])
-def flipLines (I : Type) [Fintype I] [DecidableEq I] : Move I≃ Move I where
-  toFun := Move.dual
-  invFun := Move.dual
-  left_inv _ := rfl
-  right_inv _ := rfl
-
-theorem flit_obs (M : Mat I J) (h : Injective M.mulVec) :
-    mapW unif (fun c : Move I => c.L*M)=unifOn (fun A => Injective A.mulVec) := by
-  classical
-  rw [← unifOn_true]
-  refine uniform_orbit _ (by obtain ⟨i⟩ := identity_move I; exact ⟨i,trivial⟩)
-    (fun x _ => inj_comp_mat _ _ x.L_inj h) ?_
-  intro x y hx hy
-  obtain ⟨c,hc⟩ := move_exists_one hx hy
-  refine ⟨circShift c,fun _ => Iff.rfl,fun w => ?_⟩
-  change w.L*M=x ↔ c.L*w.L*M=y
-  rw [←hc,Matrix.mul_assoc]; exact (c.permMat J).injective.eq_iff.symm
-
-theorem flit_pmax (M Q : Mat I J) (h : Injective M.mulVec)
-    (ha : num J-num I≤ -1) :
-    pr unif (fun c : Move I => c.Rᵀ*M=Q) ≤ 2*bp (-num I*num J) := by
-  let P (M : Mat I J) := Injective M.mulVec
-  have ht :
-      pr unif (fun c : Move I=> c.Rᵀ*M=Q)=unifOn P Q := by
-    change pr unif (fun x : Move I => (flipLines I x).L*M=Q)=_
-    rw [← mapW_pr unif (flipLines I) (fun c => c.L*M=Q),unif_equiv]
-    exact congr_fun (flit_obs M h) Q
-  have hh : 2⁻¹ ≤ pr unif P := by
-    have hv := @unif_fail J I _ _ _ _
-    rw [pr_not,unif_law.total] at hv
-    have he := bp_le ha
-    rw [bp_neg,bp_one] at he; change 1-pr unif P ≤ _ at hv; linarith only [hv,he]
-  rw [ht,←on_unif]
-  have he : unif Q=bp (-num I*num J) := by rw [unif_apply,neg_mul,bp_neg,←cast_mat]
-  exact (on_mon unif_law.nz (show 0<(2:ℝ)⁻¹ from by norm_num) hh Q).trans_eq
-    (by rw [he,inv_inv])
-
-variable {n : ℕ}
-def plume {n : ℕ} (c : Flit n) (S : Space (Vec (Fin n))) :=
-  colSp (c.Rᵀ*pack S)
-
-theorem plume_dim (c : Flit n) (S : Space (Vec (Fin n))) : dim (plume c S)=dim S := by
-  have hh := mrk_inj.mp (inj_comp_mat c.Rᵀ _ c.dual.L_inj (pack_inj S))
-  rw [plume,colSp_dim,hh,Fintype.card_fin]
-
-omit [Fintype I] [DecidableEq I] [DecidableEq J] [DecidableEq K] in
-private theorem smaller_cols (P : Mat I J) (Q : Mat I K) (h : colSp P ≤ colSp Q) :
-    ∃ M : Mat K J,Q*M=P := by
-  classical
-  choose f hf using fun i : J =>
-    show ∃ z : Vec K,Q *ᵥ z=P.col i from h (colSp_mem i)
-  refine ⟨Matrix.of (fun i j => f j i),?_⟩
-  ext i j; exact congr_fun (hf j) i
-
-set_option maxHeartbeats 800000 in
-theorem plume_meets (n a : ℕ) (ha : a<n) (U V : Space (Vec (Fin n))) :
-    pr unif (fun c : Flit n => a≤dim (c.plume U ⊓ V : Space (Vec (Fin n))))≤
-      bp (1+((dim U:ℝ)+dim V-n)*a) := by
-  classical
-  let P := Mat (Fin (dim U)) (Fin a); let Q := Mat (Fin (dim V)) (Fin a)
-  let S (z : P×Q) := pack U*z.1
-  let q (p : P × Q) (c : Flit n) :=
-    Injective (S p).mulVec∧c.Rᵀ*S p=pack V*p.2
-  have hi (c : Flit n) (hc : a≤dim (c.plume U ⊓ V : Space (Vec (Fin n)))) :
-      ∃ i,q i c := by
-    let w := c.plume U⊓V
-    obtain ⟨M,hM,hg⟩ := bounded_pack w a
-    have he : Injective M.mulVec := mrk_inj.mpr (by
-      rw [← colSp_dim,hg,Fintype.card_fin,min_eq_right hc])
-    have hU := le_trans hM (show w≤c.plume U from inf_le_left)
-    have hV : colSp M ≤ colSp (pack V) := by rw [colSp_pack]; exact le_trans hM inf_le_right
-    obtain ⟨P,hp⟩ := smaller_cols _ _ hU
-    obtain ⟨Q,hq��� := smaller_cols _ _ hV
-    rw [Matrix.mul_assoc] at hp
-    refine ⟨(P,Q),?_,hp.trans hq.symm⟩
-    have hx (z : Vec (Fin a)) :
-        c.Rᵀ*ᵥ((pack U * P)*ᵥz)= M*ᵥz := by rw [mulVec_mulVec,hp]
-    intro i j hg; exact he ((hx i).symm.trans ((congrArg _ hg).trans (hx j)))
-  have ht (i : P × Q) :
-      pr unif (q i) ≤2*bp (-(n:ℝ)*a) := by
-    by_cases h : Injective (S i).mulVec
-    · unfold q; simp only [h,true_and]
-      have hx : num (Fin a)-num (Fin n) ≤ -1 := by
-        simp only [num,Fintype.card_fin]
-        have hi : (a:ℝ)+1≤n := by exact_mod_cast ha
-        linarith only [hi]
-      simpa only [num,Fintype.card_fin] using flit_pmax (S i) (pack V*i.2) h hx
-    simp only [q,h,false_and,pr_false]
-    exact mul_nonneg (by norm_num) (bp_pos _).le
-  refine (le_trans (pr_mono unif_law.nz hi) (pr_exists_le unif_law.nz q)).trans
-    ((sum_le_sum (fun i _ => ht i)).trans_eq ?_)
-  simp only [Finset.sum_const,Finset.card_univ,nsmul_eq_mul,Fintype.card_prod,Nat.cast_mul]
-  change num P*num Q* _=_
-  unfold P Q; rw [cast_mat,cast_mat,←bp_one,←bp_add,←bp_add,←bp_add]
-  congr 1; simp only [num,Fintype.card_fin]; ring
-end Move
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.FrameRotations
+
+namespace OAI
+
+/-! # Random Linear Transforms -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Matrix Module LinearMap Submodule Finset Function
+open scoped BigOperators
+variable {I J K : Type} [Fintype I] [DecidableEq I] [Fintype J] [DecidableEq J]
+    [Fintype K] [DecidableEq K]
+
+namespace Move
+
+instance finiteMove (I : Type) [Fintype I] [DecidableEq I] : Fintype (Move I) := by
+  classical
+  let S := { z : Mat I I × Mat I I // z.1*z.2 = 1 ∧ z.2*z.1=1}
+  let e : S ≃ Move I := {
+    toFun z := ⟨z.val.1,z.val.2,z.property.1,z.property.2⟩
+    invFun z := ⟨(z.L,z.R),z.LR,z.RL⟩
+    left_inv _ := rfl
+    right_inv _ := rfl }
+  exact Fintype.ofEquiv S e
+
+instance identity_move (I : Type) [Fintype I] [DecidableEq I] : Nonempty (Move I) :=
+  ⟨1,1, Matrix.one_mul _,Matrix.mul_one _⟩
+def combine (c d : Move I) : Move I :=
+  ⟨c.L*d.L,d.R*c.R,by rw [Matrix.mul_assoc,←Matrix.mul_assoc d.L,d.LR,Matrix.one_mul,c.LR],
+    by rw [Matrix.mul_assoc,←Matrix.mul_assoc c.R,c.RL,Matrix.one_mul,d.RL]⟩
+
+@[ext] theorem extn (p q : Move I) (h : p.L=q.L) (h' : p.R=q.R) : p=q := by
+  cases p; cases q; cases h; cases h'; rfl
+def circShift (c : Move I) : Move I≃ Move I where
+  toFun := combine c
+  invFun := combine c.sym
+  left_inv d := extn _ _ (by simp only [combine,sym,←Matrix.mul_assoc,c.RL, Matrix.one_mul])
+    (by simp only [combine,sym,Matrix.mul_assoc,c.RL, Matrix.mul_one])
+  right_inv d := extn _ _ (by simp only [combine,sym,←Matrix.mul_assoc,c.LR, Matrix.one_mul])
+    (by simp only [combine,sym,Matrix.mul_assoc,c.LR, Matrix.mul_one])
+def flipLines (I : Type) [Fintype I] [DecidableEq I] : Move I≃ Move I where
+  toFun := Move.dual
+  invFun := Move.dual
+  left_inv _ := rfl
+  right_inv _ := rfl
+
+theorem flit_obs (M : Mat I J) (h : Injective M.mulVec) :
+    mapW unif (fun c : Move I => c.L*M)=unifOn (fun A => Injective A.mulVec) := by
+  classical
+  rw [← unifOn_true]
+  refine uniform_orbit _ (by obtain ⟨i⟩ := identity_move I; exact ⟨i,trivial⟩)
+    (fun x _ => inj_comp_mat _ _ x.L_inj h) ?_
+  intro x y hx hy
+  obtain ⟨c,hc⟩ := move_exists_one hx hy
+  refine ⟨circShift c,fun _ => Iff.rfl,fun w => ?_⟩
+  change w.L*M=x ↔ c.L*w.L*M=y
+  rw [←hc,Matrix.mul_assoc]; exact (c.permMat J).injective.eq_iff.symm
+
+theorem flit_pmax (M Q : Mat I J) (h : Injective M.mulVec)
+    (ha : num J-num I≤ -1) :
+    pr unif (fun c : Move I => c.Rᵀ*M=Q) ≤ 2*bp (-num I*num J) := by
+  let P (M : Mat I J) := Injective M.mulVec
+  have ht :
+      pr unif (fun c : Move I=> c.Rᵀ*M=Q)=unifOn P Q := by
+    change pr unif (fun x : Move I => (flipLines I x).L*M=Q)=_
+    rw [← mapW_pr unif (flipLines I) (fun c => c.L*M=Q),unif_equiv]
+    exact congr_fun (flit_obs M h) Q
+  have hh : 2⁻¹ ≤ pr unif P := by
+    have hv := @unif_fail J I _ _ _ _
+    rw [pr_not,unif_law.total] at hv
+    have he := bp_le ha
+    rw [bp_neg,bp_one] at he; change 1-pr unif P ≤ _ at hv; linarith only [hv,he]
+  rw [ht,←on_unif]
+  have he : unif Q=bp (-num I*num J) := by rw [unif_apply,neg_mul,bp_neg,←cast_mat]
+  exact (on_mon unif_law.nz (show 0<(2:ℝ)⁻¹ from by norm_num) hh Q).trans_eq
+    (by rw [he,inv_inv])
+
+variable {n : ℕ}
+def plume {n : ℕ} (c : Flit n) (S : Space (Vec (Fin n))) :=
+  colSp (c.Rᵀ*pack S)
+
+theorem plume_dim (c : Flit n) (S : Space (Vec (Fin n))) : dim (plume c S)=dim S := by
+  have hh := mrk_inj.mp (inj_comp_mat c.Rᵀ _ c.dual.L_inj (pack_inj S))
+  rw [plume,colSp_dim,hh,Fintype.card_fin]
+
+omit [Fintype I] [DecidableEq I] [DecidableEq J] [DecidableEq K] in
+private theorem smaller_cols (P : Mat I J) (Q : Mat I K) (h : colSp P ≤ colSp Q) :
+    ∃ M : Mat K J,Q*M=P := by
+  classical
+  choose f hf using fun i : J =>
+    show ∃ z : Vec K,Q *ᵥ z=P.col i from h (colSp_mem i)
+  refine ⟨Matrix.of (fun i j => f j i),?_⟩
+  ext i j; exact congr_fun (hf j) i
+
+set_option maxHeartbeats 800000 in
+theorem plume_meets (n a : ℕ) (ha : a<n) (U V : Space (Vec (Fin n))) :
+    pr unif (fun c : Flit n => a≤dim (c.plume U ⊓ V : Space (Vec (Fin n))))≤
+      bp (1+((dim U:ℝ)+dim V-n)*a) := by
+  classical
+  let P := Mat (Fin (dim U)) (Fin a); let Q := Mat (Fin (dim V)) (Fin a)
+  let S (z : P×Q) := pack U*z.1
+  let q (p : P × Q) (c : Flit n) :=
+    Injective (S p).mulVec∧c.Rᵀ*S p=pack V*p.2
+  have hi (c : Flit n) (hc : a≤dim (c.plume U ⊓ V : Space (Vec (Fin n)))) :
+      ∃ i,q i c := by
+    let w := c.plume U⊓V
+    obtain ⟨M,hM,hg⟩ := bounded_pack w a
+    have he : Injective M.mulVec := mrk_inj.mpr (by
+      rw [← colSp_dim,hg,Fintype.card_fin,min_eq_right hc])
+    have hU := le_trans hM (show w≤c.plume U from inf_le_left)
+    have hV : colSp M ≤ colSp (pack V) := by rw [colSp_pack]; exact le_trans hM inf_le_right
+    obtain ⟨P,hp⟩ := smaller_cols _ _ hU
+    obtain ⟨Q,hq⟩ := smaller_cols _ _ hV
+    rw [Matrix.mul_assoc] at hp
+    refine ⟨(P,Q),?_,hp.trans hq.symm⟩
+    have hx (z : Vec (Fin a)) :
+        c.Rᵀ*ᵥ((pack U * P)*ᵥz)= M*ᵥz := by rw [mulVec_mulVec,hp]
+    intro i j hg; exact he ((hx i).symm.trans ((congrArg _ hg).trans (hx j)))
+  have ht (i : P × Q) :
+      pr unif (q i) ≤2*bp (-(n:ℝ)*a) := by
+    by_cases h : Injective (S i).mulVec
+    · unfold q; simp only [h,true_and]
+      have hx : num (Fin a)-num (Fin n) ≤ -1 := by
+        simp only [num,Fintype.card_fin]
+        have hi : (a:ℝ)+1≤n := by exact_mod_cast ha
+        linarith only [hi]
+      simpa only [num,Fintype.card_fin] using flit_pmax (S i) (pack V*i.2) h hx
+    simp only [q,h,false_and,pr_false]
+    exact mul_nonneg (by norm_num) (bp_pos _).le
+  refine (le_trans (pr_mono unif_law.nz hi) (pr_exists_le unif_law.nz q)).trans
+    ((sum_le_sum (fun i _ => ht i)).trans_eq ?_)
+  simp only [Finset.sum_const,Finset.card_univ,nsmul_eq_mul,Fintype.card_prod,Nat.cast_mul]
+  change num P*num Q* _=_
+  unfold P Q; rw [cast_mat,cast_mat,←bp_one,←bp_add,←bp_add,←bp_add]
+  congr 1; simp only [num,Fintype.card_fin]; ring
+end Move
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/RankEfficientDecomposition.lean

@@ -1,130 +1,130 @@
-import OAI.Combinatorics.HadwigerCounterexample.DerivativeCompression
-
-namespace OAI
-
-/-! # Rank Efficient Decomposition -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Matrix LinearMap Module Submodule Finset
-open scoped BigOperators
-variable {p : Shape} {n : ℕ} {I : Type} [Fintype I]
-
-/-- Evaluation of individual matrices on Xpair -/
-def obsI (p : Shape) {n} : Individual p n →ₗ[F] ReqF p n where
-  toFun A := combineF p (repF p A)
-  map_add' A B := by
-    rw [←map_add]; apply congrArg
-    funext i; refine LinearMap.ext fun x => ?_
-    change repF p (A+B) i x= repF p A i x+ repF p B i x
-    rw [repF_rep, repF_rep,repF_rep]
-    simp only [Pi.add_apply,mpair_add,Finset.sum_add_distrib]
-  map_smul' a A := by
-    change combineF p (repF p (a•A))=a • _
-    rw [←map_smul]; apply congrArg
-    funext i; refine LinearMap.ext fun x => ?_
-    change repF p (a•A) i x= a • (repF p A i x)
-    rw [repF_rep,repF_rep]
-    simp only [Pi.smul_apply,mpair_smul,smul_eq_mul,Finset.mul_sum]
-
-theorem obsI_each (P : PureForms p n) :
-    obsI p (eachF p P)=obsPair p P :=
-  (obsPair_each P).symm
-
-private theorem mrk_sub {I J : Type} [Fintype I] [Fintype J] (A B : Mat I J) :
-    (A-B).rank ≤ A.rank+B.rank := by rw [ZModModule.sub_eq_add]; exact mrk_add_le A B
-
-theorem primary_initial (M : Individual p n) (f : Plan p n) (H R : ℕ)
-    (hF : ∀ z i,dim (sPin f z i) ≤ H) (hR : ∀ i e, (M i e).rank≤R) :
-    ∃ P∈pureSpace p f, (∀ e,(P e).rank ≤ 2*R) ∧
-      (∀ i e, ((M-eachF p P) i e).rank≤2*H) := by
-  classical
-  let S := sPin f
-  choose A hA using fun z i => proj_exists (S z i) ⊥ disjoint_bot_right
-  let B (z i) := 1-A z i
-  let T : Individual p n := fun i e => pullM (B (e,true) i) (B (e,false) i) (M i e)
-  refine ⟨sumF p T,?_,fun e => ?_, fun i e => ?_⟩
-  · refine (pureSpace_mem _).mpr fun e => ?_
-    apply Submodule.sum_mem
-    intro i _
-    let P z := B (e,z) i * (IP p n i)ᵀ
-    have he (z : Bool) (x : Dir p n) (hx : x∈f (e,z)) : P z *ᵥ x=0 := by
-      unfold P B
-      let y := (IP p n i)ᵀ *ᵥ x
-      have hh : y∈ S (e,z) i := ⟨_,hx,rfl⟩
-      rw [←Matrix.mulVec_mulVec,Matrix.sub_mulVec,Matrix.one_mulVec]
-      change y - A (e,z) i *ᵥ y=0
-      rw [(hA _ _).fixes _ hh,sub_self]
-    have hh : liftM (IP p n i) (IP p n i) (T i e)=(P true)ᵀ * M i e * P false := by
-      simp only [liftM_def,T,pullM_def,P,Matrix.transpose_mul,Matrix.transpose_transpose,
-        Matrix.mul_assoc]
-    rw [hh,box_kill]
-    constructor
-    · intro x hx
-      simp only [transpose_mul,transpose_transpose,←mulVec_mulVec,he true x hx,mulVec_zero]
-    intro x hx
-    rw [← Matrix.mulVec_mulVec,he false x hx,mulVec_zero]
-  · refine (mrk_sum_le ..).trans ?_
-    have ht i : (liftM (IP p n i) (IP p n i) (T i e)).rank≤R := (rank_lift_le ..).trans
-      ((rank_lift_le ..).trans (hR i e))
-    exact (Fintype.sum_bool _).le.trans ((Nat.add_le_add (ht _) (ht _)).trans_eq (two_mul R).symm)
-  · rw [each_sumF]
-    let z : Place p := (e,true)
-    let z' : Place p := (e,false)
-    let C := M i e
-    change (C-(T i e)).rank≤2*H
-    have he : C-T i e=(A z i)ᵀ*C+(B z i)ᵀ*C*A z' i := by
-      unfold T; rw [pullM_def]
-      dsimp only [B]
-      simp only [transpose_sub,Matrix.transpose_one,Matrix.mul_sub,Matrix.sub_mul,Matrix.mul_one,
-        Matrix.one_mul,C,z,z']
-      abel
-    have hh (z) : (A z i).rank ≤ H := (rank_maps (S z i) ((hA z i).onto)).trans (hF z i)
-    rw [he,two_mul]
-    refine (mrk_add_le ..).trans ?_
-    exact Nat.add_le_add ((Matrix.rank_mul_le_left ..).trans (Matrix.rank_transpose (A z i) ▸ hh z))
-      ((Matrix.rank_mul_le_right ..).trans (hh z'))
-
-set_option maxHeartbeats 800000 in
-theorem split_linear {M : Individual p n} {f b : Plan p n} {j : Bool}
-    {C D : ChanOut p n} {P : PureForms p n}
-    (R T H : ℕ) (ht : ∀ z i,dim (sPin f z i)≤T) (hm : ∀ i e,(M i e).rank≤R)
-    (hc : outSmall H C)
-    (hd : D∈deltaSpace p f b j) (hp : P∈pureSpace p f)
-    (hh : obsPair p (chanInner p C C)+obsPair p (chanDeriv p C D)+obsPair p P=obsI p M) :
-    ∃ (B : ChanOut p n) (P' P0 : PureForms p n) (Mr : Individual p n),
-      B∈deltaSpace p f b j ∧ P'∈pureSpace p f ∧ P0∈pureSpace p f ∧
-      outSmall (3*H) (C+B) ∧ (∀ e,(P0 e).rank≤2*R) ∧
-      obsPair p (chanInner p (C+B) (C+B))+obsPair p (P'+P0)=obsI p M ∧
-      obsPair p P'=obsI p Mr ∧ ∀ i e, (Mr i e).rank ≤2*T+3*H := by
-  classical
-  obtain ⟨B,hB,hK,hZ⟩ := deriv_compress hc hd
-  obtain ⟨P0,hQ,hA,hL⟩ := primary_initial M f T R ht hm
-  let P' := P-chanInner p B B-P0
-  let CI := chanInner p (C+B) (C+B)
-  let E := eachF p CI
-  refine ⟨B,P',P0,M-eachF p P0-E,hB,(pureSpace p f).sub_mem
-    ((pureSpace p f).sub_mem hp (chanInner_pure hB hB)) hQ,hQ,?_⟩
-  have hsmall : outSmall (3*H) (C+B) := by
-    intro z i
-    rw [Pi.add_apply,Matrix.add_mul]
-    apply le_trans (mrk_add_le ..)
-    exact (Nat.add_le_add (hc z i) ((Matrix.rank_mul_le_left ..).trans (hK z))).trans
-      (by omega)
-  have hg : obsPair p (chanInner p (C+B) (C+B)) + obsPair p (P'+P0)=obsI p M := by
-    rw [obsPair_chan_change,←hZ,show P'=P-chanInner p B B-P0 from rfl,sub_add_cancel,map_sub]
-    exact (show _=obsPair p (chanInner p C C)+obsPair p (chanDeriv p C D)+obsPair p P by
-      abel).trans hh
-  refine ⟨hsmall,hA,hg,?_,fun i e => ?_⟩
-  · rw [map_sub (obsI p) (M-eachF p P0) E,map_sub (obsI p),← hg]
-    rw [obsI_each,show E= eachF p CI from rfl,obsI_each]
-    unfold CI
-    rw [map_add]; abel
-  rw [Pi.sub_apply,Pi.sub_apply]
-  exact (mrk_sub ..).trans (Nat.add_le_add (hL i e) (show (E i e).rank≤_ from by
-    unfold E CI; rw [each_chan_val]; exact (Matrix.rank_mul_le_right ..).trans (hsmall _ i)))
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.DerivativeCompression
+
+namespace OAI
+
+/-! # Rank Efficient Decomposition -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Matrix LinearMap Module Submodule Finset
+open scoped BigOperators
+variable {p : Shape} {n : ℕ} {I : Type} [Fintype I]
+
+/-- Evaluation of individual matrices on Xpair -/
+def obsI (p : Shape) {n} : Individual p n →ₗ[F] ReqF p n where
+  toFun A := combineF p (repF p A)
+  map_add' A B := by
+    rw [←map_add]; apply congrArg
+    funext i; refine LinearMap.ext fun x => ?_
+    change repF p (A+B) i x= repF p A i x+ repF p B i x
+    rw [repF_rep, repF_rep,repF_rep]
+    simp only [Pi.add_apply,mpair_add,Finset.sum_add_distrib]
+  map_smul' a A := by
+    change combineF p (repF p (a•A))=a • _
+    rw [←map_smul]; apply congrArg
+    funext i; refine LinearMap.ext fun x => ?_
+    change repF p (a•A) i x= a • (repF p A i x)
+    rw [repF_rep,repF_rep]
+    simp only [Pi.smul_apply,mpair_smul,smul_eq_mul,Finset.mul_sum]
+
+theorem obsI_each (P : PureForms p n) :
+    obsI p (eachF p P)=obsPair p P :=
+  (obsPair_each P).symm
+
+private theorem mrk_sub {I J : Type} [Fintype I] [Fintype J] (A B : Mat I J) :
+    (A-B).rank ≤ A.rank+B.rank := by rw [ZModModule.sub_eq_add]; exact mrk_add_le A B
+
+theorem primary_initial (M : Individual p n) (f : Plan p n) (H R : ℕ)
+    (hF : ∀ z i,dim (sPin f z i) ≤ H) (hR : ∀ i e, (M i e).rank≤R) :
+    ∃ P∈pureSpace p f, (∀ e,(P e).rank ≤ 2*R) ∧
+      (∀ i e, ((M-eachF p P) i e).rank≤2*H) := by
+  classical
+  let S := sPin f
+  choose A hA using fun z i => proj_exists (S z i) ⊥ disjoint_bot_right
+  let B (z i) := 1-A z i
+  let T : Individual p n := fun i e => pullM (B (e,true) i) (B (e,false) i) (M i e)
+  refine ⟨sumF p T,?_,fun e => ?_, fun i e => ?_⟩
+  · refine (pureSpace_mem _).mpr fun e => ?_
+    apply Submodule.sum_mem
+    intro i _
+    let P z := B (e,z) i * (IP p n i)ᵀ
+    have he (z : Bool) (x : Dir p n) (hx : x∈f (e,z)) : P z *ᵥ x=0 := by
+      unfold P B
+      let y := (IP p n i)ᵀ *ᵥ x
+      have hh : y∈ S (e,z) i := ⟨_,hx,rfl⟩
+      rw [←Matrix.mulVec_mulVec,Matrix.sub_mulVec,Matrix.one_mulVec]
+      change y - A (e,z) i *ᵥ y=0
+      rw [(hA _ _).fixes _ hh,sub_self]
+    have hh : liftM (IP p n i) (IP p n i) (T i e)=(P true)ᵀ * M i e * P false := by
+      simp only [liftM_def,T,pullM_def,P,Matrix.transpose_mul,Matrix.transpose_transpose,
+        Matrix.mul_assoc]
+    rw [hh,box_kill]
+    constructor
+    · intro x hx
+      simp only [transpose_mul,transpose_transpose,←mulVec_mulVec,he true x hx,mulVec_zero]
+    intro x hx
+    rw [← Matrix.mulVec_mulVec,he false x hx,mulVec_zero]
+  · refine (mrk_sum_le ..).trans ?_
+    have ht i : (liftM (IP p n i) (IP p n i) (T i e)).rank≤R := (rank_lift_le ..).trans
+      ((rank_lift_le ..).trans (hR i e))
+    exact (Fintype.sum_bool _).le.trans ((Nat.add_le_add (ht _) (ht _)).trans_eq (two_mul R).symm)
+  · rw [each_sumF]
+    let z : Place p := (e,true)
+    let z' : Place p := (e,false)
+    let C := M i e
+    change (C-(T i e)).rank≤2*H
+    have he : C-T i e=(A z i)ᵀ*C+(B z i)ᵀ*C*A z' i := by
+      unfold T; rw [pullM_def]
+      dsimp only [B]
+      simp only [transpose_sub,Matrix.transpose_one,Matrix.mul_sub,Matrix.sub_mul,Matrix.mul_one,
+        Matrix.one_mul,C,z,z']
+      abel
+    have hh (z) : (A z i).rank ≤ H := (rank_maps (S z i) ((hA z i).onto)).trans (hF z i)
+    rw [he,two_mul]
+    refine (mrk_add_le ..).trans ?_
+    exact Nat.add_le_add ((Matrix.rank_mul_le_left ..).trans (Matrix.rank_transpose (A z i) ▸ hh z))
+      ((Matrix.rank_mul_le_right ..).trans (hh z'))
+
+set_option maxHeartbeats 800000 in
+theorem split_linear {M : Individual p n} {f b : Plan p n} {j : Bool}
+    {C D : ChanOut p n} {P : PureForms p n}
+    (R T H : ℕ) (ht : ∀ z i,dim (sPin f z i)≤T) (hm : ∀ i e,(M i e).rank≤R)
+    (hc : outSmall H C)
+    (hd : D∈deltaSpace p f b j) (hp : P∈pureSpace p f)
+    (hh : obsPair p (chanInner p C C)+obsPair p (chanDeriv p C D)+obsPair p P=obsI p M) :
+    ∃ (B : ChanOut p n) (P' P0 : PureForms p n) (Mr : Individual p n),
+      B∈deltaSpace p f b j ∧ P'∈pureSpace p f ∧ P0∈pureSpace p f ∧
+      outSmall (3*H) (C+B) ∧ (∀ e,(P0 e).rank≤2*R) ∧
+      obsPair p (chanInner p (C+B) (C+B))+obsPair p (P'+P0)=obsI p M ∧
+      obsPair p P'=obsI p Mr ∧ ∀ i e, (Mr i e).rank ≤2*T+3*H := by
+  classical
+  obtain ⟨B,hB,hK,hZ⟩ := deriv_compress hc hd
+  obtain ⟨P0,hQ,hA,hL⟩ := primary_initial M f T R ht hm
+  let P' := P-chanInner p B B-P0
+  let CI := chanInner p (C+B) (C+B)
+  let E := eachF p CI
+  refine ⟨B,P',P0,M-eachF p P0-E,hB,(pureSpace p f).sub_mem
+    ((pureSpace p f).sub_mem hp (chanInner_pure hB hB)) hQ,hQ,?_⟩
+  have hsmall : outSmall (3*H) (C+B) := by
+    intro z i
+    rw [Pi.add_apply,Matrix.add_mul]
+    apply le_trans (mrk_add_le ..)
+    exact (Nat.add_le_add (hc z i) ((Matrix.rank_mul_le_left ..).trans (hK z))).trans
+      (by omega)
+  have hg : obsPair p (chanInner p (C+B) (C+B)) + obsPair p (P'+P0)=obsI p M := by
+    rw [obsPair_chan_change,←hZ,show P'=P-chanInner p B B-P0 from rfl,sub_add_cancel,map_sub]
+    exact (show _=obsPair p (chanInner p C C)+obsPair p (chanDeriv p C D)+obsPair p P by
+      abel).trans hh
+  refine ⟨hsmall,hA,hg,?_,fun i e => ?_⟩
+  · rw [map_sub (obsI p) (M-eachF p P0) E,map_sub (obsI p),← hg]
+    rw [obsI_each,show E= eachF p CI from rfl,obsI_each]
+    unfold CI
+    rw [map_add]; abel
+  rw [Pi.sub_apply,Pi.sub_apply]
+  exact (mrk_sub ..).trans (Nat.add_le_add (hL i e) (show (E i e).rank≤_ from by
+    unfold E CI; rw [each_chan_val]; exact (Matrix.rank_mul_le_right ..).trans (hsmall _ i)))
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/RankSubrectangles.lean

@@ -1,126 +1,126 @@
-import OAI.Combinatorics.HadwigerCounterexample.GramCharacterExpansion
-
-namespace OAI
-
-/-! # Rank Subrectangles -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Matrix Module LinearMap Submodule Function Finset
-open scoped BigOperators
-variable {I J G : Type} [Fintype I] [Fintype J] [Fintype G] [DecidableEq I] [DecidableEq J]
-
-omit [DecidableEq I] in
-theorem basis_subcolumns (A : Mat I J) :
-    ∃ f : Fin A.rank→J, Injective (A.submatrix _root_.id f).mulVec := by
-  classical
-  let M (S : Finset J) := Submodule.span F (A.col '' (S : Set J))
-  have hg (S : Finset J) : ∃ T⊆S,M T=M S ∧ T.card=dim (M T) := by
-    induction S using Finset.induction with
-    | empty =>
-      have he : M ∅ = ⊥ := by
-        unfold M
-        rw [show (A.col '' ((∅ : Finset J) : Set _))=∅ by ext; simp, Submodule.span_empty]
-      refine ⟨∅,by simp,rfl,?_⟩; rw [he]; exact (finrank_bot ..).symm
-    | insert x S hx ih =>
-      obtain ⟨T,hT,hM,hD⟩ := ih
-      have he (S : Finset J) :
-          M (insert x S)=M S⊔Submodule.span F ({A.col x}:Set _) := by
-        unfold M
-        rw [← span_union]
-        congr 1
-        ext; simp
-      rw [he,←hM]
-      by_cases h : A.col x∈M T
-      · exact ⟨T,hT.trans (Finset.subset_insert _ _),
-          (sup_eq_left.mpr (by rwa [Submodule.span_singleton_le_iff_mem])).symm,hD⟩
-      refine ⟨insert x T,Finset.insert_subset_insert x hT,he T,?_⟩
-      rw [Finset.card_insert_of_notMem (fun v => hx (hT v)), he,hD]
-      exact (Submodule.finrank_sup_span_singleton h).symm
-  obtain ⟨S,hS,hA,ht⟩ := hg Finset.univ
-  have hs : M S=colSp A := by
-    rw [hA,colSp, Matrix.range_mulVecLin]; unfold M
-    congr 1
-    ext x; simp
-  have he : S.card=A.rank := by rw [ht,hs,colSp_dim]
-  let e := Fintype.equivFinOfCardEq (Fintype.card_coe S |>.trans he)
-  let f (x : Fin A.rank) := (e.symm x).val
-  have hB : colSp (A.submatrix _root_.id f)=M S := by
-    rw [colSp,Matrix.range_mulVecLin]; unfold M
-    congr 1
-    ext x; constructor
-    · rintro ⟨k,rfl⟩; exact ⟨f k,(e.symm k).property,rfl⟩
-    · rintro ⟨k,h,rfl⟩
-      refine ⟨e ⟨k,h⟩,?_⟩
-      have heq : f (e ⟨k,h⟩) = k := by unfold f; rw [Equiv.symm_apply_apply]
-      ext; simp [Matrix.col_apply,heq]
-  rw [hs] at hB
-  refine ⟨f,mrk_inj.mpr ?_⟩
-  rw [← colSp_dim,hB,Fintype.card_fin,colSp_dim]
-
-theorem minor_arc (A : Mat I J) :
-    ∃ (f : Fin A.rank→ I) (g : Fin A.rank→ J), Injective (A.submatrix f g).mulVec := by
-  classical
-  let t := A.rank
-  obtain ⟨g,hg⟩ := basis_subcolumns A
-  let B := A.submatrix _root_.id g
-  have he : Bᵀ.rank=t := (Matrix.rank_transpose _).trans ((mrk_inj.mp hg).trans
-    (Fintype.card_fin _))
-  obtain ⟨f,hf⟩ : ∃ f : Fin t→I,Injective ((Bᵀ.submatrix _root_.id f)).mulVec := by
-    have hi := basis_subcolumns Bᵀ
-    rwa [he] at hi
-  have hh := mrk_inj.mp hf
-  refine ⟨f,g,mrk_inj.mpr ?_⟩
-  rw [← Matrix.rank_transpose]
-  exact hh
-
-private theorem lastCol {t : ℕ} {I J : Type} [Fintype I] [Fintype J]
-    [DecidableEq I] [DecidableEq J] (A : Mat I J)
-    (f : Fin t→I) (g : Fin t→J) (x : I) (y : J)
-    (h : (A.submatrix (Sum.elim f (fun _ : Unit => x))
-      (Sum.elim g (fun _ : Unit => y))).rank ≤ t)
-    (hb : Injective (A.submatrix f g).mulVec) :
-    ∃ z : Vec (Fin t),(A.submatrix f g)*ᵥ z=(fun i => A (f i) y) ∧
-      A x y=∑ i,A x (g i)*z i := by
-  classical
-  let C := A.submatrix (Sum.elim f (fun _ : Unit => x)) (Sum.elim g (fun _ : Unit => y))
-  let M := C.submatrix _root_.id (.inl ·)
-  have hm : Injective M.mulVec := by
-    intro X Y h
-    apply hb
-    funext i
-    exact congr_fun h (.inl i)
-  have hM : colSp M≤colSp C := by
-    rw [colSp,colSp, Matrix.range_mulVecLin,Matrix.range_mulVecLin]
-    apply Submodule.span_mono
-    rintro s ⟨i,rfl⟩; exact ⟨.inl i,rfl⟩
-  have he : colSp M=colSp C := Submodule.eq_of_le_of_finrank_le hM (by
-    have he : dim (colSp M)=t := (mrk_inj.mp hm).trans (Fintype.card_fin _)
-    change dim (colSp C) ≤ dim (colSp M)
-    rw [he]; exact h)
-  obtain ⟨v,hv⟩ := show C.col (.inr ()) ∈ colSp M from he.symm ▸ colSp_mem _
-  exact ⟨v,funext (fun i => congr_fun hv (.inl i)),(congr_fun hv (.inr ())).symm⟩
-
-theorem border_same {t : ℕ} (A B : Mat I J) (f : Fin t→I) (g : Fin t→J)
-    (x : I) (y : J)
-    (h : Injective (A.submatrix f g).mulVec)
-    (hx : ∀ i j,A (f i) j=B (f i) j)
-    (hy : ∀ i j,A i (g j)=B i (g j))
-    (hA : (A.submatrix (Sum.elim f (fun _ : Unit => x))
-      (Sum.elim g (fun _ : Unit => y))).rank ≤ t)
-    (hB : (B.submatrix (Sum.elim f (fun _ : Unit => x))
-      (Sum.elim g (fun _ : Unit => y))).rank ≤ t) :
-    A x y=B x y := by
-  classical
-  have hh : A.submatrix f g=B.submatrix f g := Matrix.ext fun i j => hx i _
-  obtain ⟨s,hs,hL⟩ := lastCol A f g x y hA h
-  obtain ⟨s',hs',hR⟩ := lastCol B f g x y hB (hh ▸ h)
-  obtain rfl : s=s' := h ((show A.submatrix f g *ᵥ s=(fun i => A (f i) y) from hs).trans
-    ((funext (fun i => hx i y)).trans (hh ▸ hs'.symm)))
-  rw [hL,hR]; simp_rw [hy]
-
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.GramCharacterExpansion
+
+namespace OAI
+
+/-! # Rank Subrectangles -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Matrix Module LinearMap Submodule Function Finset
+open scoped BigOperators
+variable {I J G : Type} [Fintype I] [Fintype J] [Fintype G] [DecidableEq I] [DecidableEq J]
+
+omit [DecidableEq I] in
+theorem basis_subcolumns (A : Mat I J) :
+    ∃ f : Fin A.rank→J, Injective (A.submatrix _root_.id f).mulVec := by
+  classical
+  let M (S : Finset J) := Submodule.span F (A.col '' (S : Set J))
+  have hg (S : Finset J) : ∃ T⊆S,M T=M S ∧ T.card=dim (M T) := by
+    induction S using Finset.induction with
+    | empty =>
+      have he : M ∅ = ⊥ := by
+        unfold M
+        rw [show (A.col '' ((∅ : Finset J) : Set _))=∅ by ext; simp, Submodule.span_empty]
+      refine ⟨∅,by simp,rfl,?_⟩; rw [he]; exact (finrank_bot ..).symm
+    | insert x S hx ih =>
+      obtain ⟨T,hT,hM,hD⟩ := ih
+      have he (S : Finset J) :
+          M (insert x S)=M S⊔Submodule.span F ({A.col x}:Set _) := by
+        unfold M
+        rw [← span_union]
+        congr 1
+        ext; simp
+      rw [he,←hM]
+      by_cases h : A.col x∈M T
+      · exact ⟨T,hT.trans (Finset.subset_insert _ _),
+          (sup_eq_left.mpr (by rwa [Submodule.span_singleton_le_iff_mem])).symm,hD⟩
+      refine ⟨insert x T,Finset.insert_subset_insert x hT,he T,?_⟩
+      rw [Finset.card_insert_of_notMem (fun v => hx (hT v)), he,hD]
+      exact (Submodule.finrank_sup_span_singleton h).symm
+  obtain ⟨S,hS,hA,ht⟩ := hg Finset.univ
+  have hs : M S=colSp A := by
+    rw [hA,colSp, Matrix.range_mulVecLin]; unfold M
+    congr 1
+    ext x; simp
+  have he : S.card=A.rank := by rw [ht,hs,colSp_dim]
+  let e := Fintype.equivFinOfCardEq (Fintype.card_coe S |>.trans he)
+  let f (x : Fin A.rank) := (e.symm x).val
+  have hB : colSp (A.submatrix _root_.id f)=M S := by
+    rw [colSp,Matrix.range_mulVecLin]; unfold M
+    congr 1
+    ext x; constructor
+    · rintro ⟨k,rfl⟩; exact ⟨f k,(e.symm k).property,rfl⟩
+    · rintro ⟨k,h,rfl⟩
+      refine ⟨e ⟨k,h⟩,?_⟩
+      have heq : f (e ⟨k,h⟩) = k := by unfold f; rw [Equiv.symm_apply_apply]
+      ext; simp [Matrix.col_apply,heq]
+  rw [hs] at hB
+  refine ⟨f,mrk_inj.mpr ?_⟩
+  rw [← colSp_dim,hB,Fintype.card_fin,colSp_dim]
+
+theorem minor_arc (A : Mat I J) :
+    ∃ (f : Fin A.rank→ I) (g : Fin A.rank→ J), Injective (A.submatrix f g).mulVec := by
+  classical
+  let t := A.rank
+  obtain ⟨g,hg⟩ := basis_subcolumns A
+  let B := A.submatrix _root_.id g
+  have he : Bᵀ.rank=t := (Matrix.rank_transpose _).trans ((mrk_inj.mp hg).trans
+    (Fintype.card_fin _))
+  obtain ⟨f,hf⟩ : ∃ f : Fin t→I,Injective ((Bᵀ.submatrix _root_.id f)).mulVec := by
+    have hi := basis_subcolumns Bᵀ
+    rwa [he] at hi
+  have hh := mrk_inj.mp hf
+  refine ⟨f,g,mrk_inj.mpr ?_⟩
+  rw [← Matrix.rank_transpose]
+  exact hh
+
+private theorem lastCol {t : ℕ} {I J : Type} [Fintype I] [Fintype J]
+    [DecidableEq I] [DecidableEq J] (A : Mat I J)
+    (f : Fin t→I) (g : Fin t→J) (x : I) (y : J)
+    (h : (A.submatrix (Sum.elim f (fun _ : Unit => x))
+      (Sum.elim g (fun _ : Unit => y))).rank ≤ t)
+    (hb : Injective (A.submatrix f g).mulVec) :
+    ∃ z : Vec (Fin t),(A.submatrix f g)*ᵥ z=(fun i => A (f i) y) ∧
+      A x y=∑ i,A x (g i)*z i := by
+  classical
+  let C := A.submatrix (Sum.elim f (fun _ : Unit => x)) (Sum.elim g (fun _ : Unit => y))
+  let M := C.submatrix _root_.id (.inl ·)
+  have hm : Injective M.mulVec := by
+    intro X Y h
+    apply hb
+    funext i
+    exact congr_fun h (.inl i)
+  have hM : colSp M≤colSp C := by
+    rw [colSp,colSp, Matrix.range_mulVecLin,Matrix.range_mulVecLin]
+    apply Submodule.span_mono
+    rintro s ⟨i,rfl⟩; exact ⟨.inl i,rfl⟩
+  have he : colSp M=colSp C := Submodule.eq_of_le_of_finrank_le hM (by
+    have he : dim (colSp M)=t := (mrk_inj.mp hm).trans (Fintype.card_fin _)
+    change dim (colSp C) ≤ dim (colSp M)
+    rw [he]; exact h)
+  obtain ⟨v,hv⟩ := show C.col (.inr ()) ∈ colSp M from he.symm ▸ colSp_mem _
+  exact ⟨v,funext (fun i => congr_fun hv (.inl i)),(congr_fun hv (.inr ())).symm⟩
+
+theorem border_same {t : ℕ} (A B : Mat I J) (f : Fin t→I) (g : Fin t→J)
+    (x : I) (y : J)
+    (h : Injective (A.submatrix f g).mulVec)
+    (hx : ∀ i j,A (f i) j=B (f i) j)
+    (hy : ∀ i j,A i (g j)=B i (g j))
+    (hA : (A.submatrix (Sum.elim f (fun _ : Unit => x))
+      (Sum.elim g (fun _ : Unit => y))).rank ≤ t)
+    (hB : (B.submatrix (Sum.elim f (fun _ : Unit => x))
+      (Sum.elim g (fun _ : Unit => y))).rank ≤ t) :
+    A x y=B x y := by
+  classical
+  have hh : A.submatrix f g=B.submatrix f g := Matrix.ext fun i j => hx i _
+  obtain ⟨s,hs,hL⟩ := lastCol A f g x y hA h
+  obtain ⟨s',hs',hR⟩ := lastCol B f g x y hB (hh ▸ h)
+  obtain rfl : s=s' := h ((show A.submatrix f g *ᵥ s=(fun i => A (f i) y) from hs).trans
+    ((funext (fun i => hx i y)).trans (hh ▸ hs'.symm)))
+  rw [hL,hR]; simp_rw [hy]
+
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/RareLeafEvents.lean

@@ -1,101 +1,101 @@
-import OAI.Combinatorics.HadwigerCounterexample.SuperlevelBounds
-
-namespace OAI
-
-/-! # Rare Leaf Events -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Filter Finset Matrix Function
-open scoped BigOperators Topology
-open Template
-variable {p:Shape} {M n N K s0:ℕ}
-namespace StatusAnalysis
-variable {q:Format} {d e:Rates} {b:Bool}
-
-namespace Quill
-variable (w:Quill p q d b) (m:Mixer p n) (t : Tagging p (Messenger q))
-    (z : Messenger q→F)
-def qualified (s:Charts p n d) (K :ℕ) (μ:Wgt (UnitType p n N)) (P : UnitType p n N→Prop) (a:ℝ) :=
-    2*a ≤ pr μ P ∧ ∀ i,P i →μ i ≠0→ w.steady t z m K s i
-
-theorem qualify_hit (s : Charts p n d) (K:ℕ) (μ:Wgt (UnitType p n N))
-    (P: UnitType p n N→Prop) (H:Keys (p:=p) t N→Prop) {a α:ℝ} (hα:0<α)
-    (h:w.qualified m t z s K μ P a)
-    (hw : IsLaw μ) (hg:∀ i,IsLaw (w.policies t z n i))
-    (hp: pr μ (fun i=>¬w.sober t z K H m α i) ≤ a) :
-    a*α ≤ pr (w.sales t z μ P m s) H := by
-  classical
-  let Q:=w.sober t z K H m α
-  let V i:=w.prowl s t z m i (fun i=>ind (H i))
-  have he:a ≤ pr μ (fun x=>P x∧ Q x) :=
-    (le_trans (by linarith only [hp,h.1]) (pr_shield hw.nz _ _))
-  unfold pr; rw [sales_mean]
-  refine (mul_le_mul_of_nonneg_right he hα.le).trans ?_
-  unfold pr; rw [←avg_mul]
-  unfold avg
-  refine Finset.sum_le_sum fun i _=> ?_
-  dsimp only
-  by_cases hi:μ i=0
-  · simp only [hi,zero_mul]; rfl
-  refine mul_le_mul_of_nonneg_left ?_ (hw.nz i)
-  have hv : 0≤ V i := avg_nonneg (prodW_law hg).nz (fun j=> mul_nonneg (ind_nonneg _) (ind_nonneg _))
-  by_cases hP:P i∧ Q i
-  · change ind (_∧_) *_ ≤ _*V i; rw [ind_one hP,ind_one hP.1,one_mul,one_mul]
-    exact hP.2 s (h.2 i hP.1 hi)
-  rw [ind_zero hP,zero_mul]; exact mul_nonneg (ind_nonneg _) hv
-end Quill
-
-namespace Station
-variable {w:LeafMixture p n N} (t:Station p n N K w) (x:Typus p q d e)
-    (m:Mixer p n) (k: Fin (2^deckMax p K)) (μ:Wgt (UnitType p n N))
-
-def charter (a:ℝ) (i:w.T×w.T) :=
-    x.permission ∧
-      x.qA.qualified m x.t x.z (t.cAxes i.1 d) K (partW μ i.1.val) (t.frontPage x m i.1 i.2 k) a ∧
-      x.qB.qualified m x.t x.z (t.cAxes i.2 e) K (partW μ i.2.val) (t.backPage x m i.1 i.2 k) a
-
-def berth (a:ℝ) :=
-    pr (pairW (portionW μ w.T) (portionW μ w.T)) (charter t x m k μ a)
-
-theorem charterWeak {a b:ℝ} (hh:a≤b) (i:w.T×w.T) (hf:charter t x m k μ b i) :
-    charter t x m k μ a i :=
-  ⟨hf.1,⟨(mul_le_mul_of_nonneg_left hh (by norm_num)).trans hf.2.1.1,hf.2.1.2⟩,
-    ⟨(mul_le_mul_of_nonneg_left hh (by norm_num)).trans hf.2.2.1,hf.2.2.2⟩⟩
-end Station
-
-variable {A I J : Type} [Fintype A] [Fintype I] [Fintype J]
-set_option maxHeartbeats 800000 in
-theorem vacantBound (w : Wgt I) (v : I→ Wgt A) (K : I→ J → A→Prop) (P : A→Prop)
-    (hw:IsLaw w) (hv:∀ i,IsLaw (v i))
-    {b e ε:ℝ} (hb : 0<b)
-    (he : ∀ i j,pr (mixW w v) (K i j) ≤ e)
-    (hf : pr (mixW w v) P≤ε) :
-    let S (i:I×I) := (∃ j,b< pr (v i.1) (K i.2 j)) ∨ b< pr (v i.2) P
-    pr (pairW w w) S ≤ num J * (e/b)+ε/b := by
-  classical
-  intro S
-  have hg Q c (h: pr (mixW w v) Q≤c) : pr w (fun i=> b< pr (v i) Q)≤ c/b := by
-    refine (le_div_iff₀ hb).mpr ?_
-    rw [mul_comm]
-    unfold pr at h; rw [mixW_avg] at h
-    let f i:=pr (v i) Q
-    apply le_trans (b:=avg w f) ?_ h
-    exact le_trans (mul_le_mul_of_nonneg_left (pr_mono hw.nz
-      (q:=fun i=>b≤f i) (fun _ hh=>hh.le)) hb.le) (le_avg_markov hw.nz (fun i=> pr_nonneg (hv _).nz) b)
-  let Q i:= pr w (fun x=>∃ j,b<pr (v x) (K i j))
-  have hh i : Q i≤num J*(e/b) := ((pr_exists_le hw.nz _).trans
-    (Finset.sum_le_sum fun j _ => hg _ _ (he i j))).trans_eq (by simp [num])
-  let U (i:I×I):=∃ j,b<pr (v i.1) (K i.2 j)
-  let V (i:I×I):=b<pr (v i.2) P
-  apply (pr_or_le (p:=U) (q:=V) (pairW_law hw hw).nz).trans
-  refine add_le_add ?_ ?_
-  · unfold pr; rw [pairW_avg,avg_avg]; exact hw.avg_le hh
-  unfold pr; rw [pairW_avg ]; exact hw.avg_le fun _=>hg _ _ hf
-
-end StatusAnalysis
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.SuperlevelBounds
+
+namespace OAI
+
+/-! # Rare Leaf Events -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Filter Finset Matrix Function
+open scoped BigOperators Topology
+open Template
+variable {p:Shape} {M n N K s0:ℕ}
+namespace StatusAnalysis
+variable {q:Format} {d e:Rates} {b:Bool}
+
+namespace Quill
+variable (w:Quill p q d b) (m:Mixer p n) (t : Tagging p (Messenger q))
+    (z : Messenger q→F)
+def qualified (s:Charts p n d) (K :ℕ) (μ:Wgt (UnitType p n N)) (P : UnitType p n N→Prop) (a:ℝ) :=
+    2*a ≤ pr μ P ∧ ∀ i,P i →μ i ≠0→ w.steady t z m K s i
+
+theorem qualify_hit (s : Charts p n d) (K:ℕ) (μ:Wgt (UnitType p n N))
+    (P: UnitType p n N→Prop) (H:Keys (p:=p) t N→Prop) {a α:ℝ} (hα:0<α)
+    (h:w.qualified m t z s K μ P a)
+    (hw : IsLaw μ) (hg:∀ i,IsLaw (w.policies t z n i))
+    (hp: pr μ (fun i=>¬w.sober t z K H m α i) ≤ a) :
+    a*α ≤ pr (w.sales t z μ P m s) H := by
+  classical
+  let Q:=w.sober t z K H m α
+  let V i:=w.prowl s t z m i (fun i=>ind (H i))
+  have he:a ≤ pr μ (fun x=>P x∧ Q x) :=
+    (le_trans (by linarith only [hp,h.1]) (pr_shield hw.nz _ _))
+  unfold pr; rw [sales_mean]
+  refine (mul_le_mul_of_nonneg_right he hα.le).trans ?_
+  unfold pr; rw [←avg_mul]
+  unfold avg
+  refine Finset.sum_le_sum fun i _=> ?_
+  dsimp only
+  by_cases hi:μ i=0
+  · simp only [hi,zero_mul]; rfl
+  refine mul_le_mul_of_nonneg_left ?_ (hw.nz i)
+  have hv : 0≤ V i := avg_nonneg (prodW_law hg).nz (fun j=> mul_nonneg (ind_nonneg _) (ind_nonneg _))
+  by_cases hP:P i∧ Q i
+  · change ind (_∧_) *_ ≤ _*V i; rw [ind_one hP,ind_one hP.1,one_mul,one_mul]
+    exact hP.2 s (h.2 i hP.1 hi)
+  rw [ind_zero hP,zero_mul]; exact mul_nonneg (ind_nonneg _) hv
+end Quill
+
+namespace Station
+variable {w:LeafMixture p n N} (t:Station p n N K w) (x:Typus p q d e)
+    (m:Mixer p n) (k: Fin (2^deckMax p K)) (μ:Wgt (UnitType p n N))
+
+def charter (a:ℝ) (i:w.T×w.T) :=
+    x.permission ∧
+      x.qA.qualified m x.t x.z (t.cAxes i.1 d) K (partW μ i.1.val) (t.frontPage x m i.1 i.2 k) a ∧
+      x.qB.qualified m x.t x.z (t.cAxes i.2 e) K (partW μ i.2.val) (t.backPage x m i.1 i.2 k) a
+
+def berth (a:ℝ) :=
+    pr (pairW (portionW μ w.T) (portionW μ w.T)) (charter t x m k μ a)
+
+theorem charterWeak {a b:ℝ} (hh:a≤b) (i:w.T×w.T) (hf:charter t x m k μ b i) :
+    charter t x m k μ a i :=
+  ⟨hf.1,⟨(mul_le_mul_of_nonneg_left hh (by norm_num)).trans hf.2.1.1,hf.2.1.2⟩,
+    ⟨(mul_le_mul_of_nonneg_left hh (by norm_num)).trans hf.2.2.1,hf.2.2.2⟩⟩
+end Station
+
+variable {A I J : Type} [Fintype A] [Fintype I] [Fintype J]
+set_option maxHeartbeats 800000 in
+theorem vacantBound (w : Wgt I) (v : I→ Wgt A) (K : I→ J → A→Prop) (P : A→Prop)
+    (hw:IsLaw w) (hv:∀ i,IsLaw (v i))
+    {b e ε:ℝ} (hb : 0<b)
+    (he : ∀ i j,pr (mixW w v) (K i j) ≤ e)
+    (hf : pr (mixW w v) P≤ε) :
+    let S (i:I×I) := (∃ j,b< pr (v i.1) (K i.2 j)) ∨ b< pr (v i.2) P
+    pr (pairW w w) S ≤ num J * (e/b)+ε/b := by
+  classical
+  intro S
+  have hg Q c (h: pr (mixW w v) Q≤c) : pr w (fun i=> b< pr (v i) Q)≤ c/b := by
+    refine (le_div_iff₀ hb).mpr ?_
+    rw [mul_comm]
+    unfold pr at h; rw [mixW_avg] at h
+    let f i:=pr (v i) Q
+    apply le_trans (b:=avg w f) ?_ h
+    exact le_trans (mul_le_mul_of_nonneg_left (pr_mono hw.nz
+      (q:=fun i=>b≤f i) (fun _ hh=>hh.le)) hb.le) (le_avg_markov hw.nz (fun i=> pr_nonneg (hv _).nz) b)
+  let Q i:= pr w (fun x=>∃ j,b<pr (v x) (K i j))
+  have hh i : Q i≤num J*(e/b) := ((pr_exists_le hw.nz _).trans
+    (Finset.sum_le_sum fun j _ => hg _ _ (he i j))).trans_eq (by simp [num])
+  let U (i:I×I):=∃ j,b<pr (v i.1) (K i.2 j)
+  let V (i:I×I):=b<pr (v i.2) P
+  apply (pr_or_le (p:=U) (q:=V) (pairW_law hw hw).nz).trans
+  refine add_le_add ?_ ?_
+  · unfold pr; rw [pairW_avg,avg_avg]; exact hw.avg_le hh
+  unfold pr; rw [pairW_avg ]; exact hw.avg_le fun _=>hg _ _ hf
+
+end StatusAnalysis
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/RareTestEvents.lean

@@ -1,132 +1,132 @@
-import OAI.Combinatorics.HadwigerCounterexample.CompatibleOptionRealization
-
-namespace OAI
-
-/-! # Rare Test Events -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Filter Finset Matrix LinearMap Module Function
-open scoped BigOperators Topology
-variable {p:Shape} {n N K M : ℕ}
-namespace StatusAnalysis
-
-def singles : Format:=fun _=>1
-def volume1 : Volumes:=fun _=>1
-theorem singles_vol : singles=toFormat volume1 := rfl
-theorem singles_card : Fintype.card (Messenger singles)=4 := by
-  decide
-theorem singles_short : ∀ i,1≤singles i ∧ singles i≤7 :=by simp [singles]
-theorem funds_one {b : Bool} {d : Rates} (f: Fabric p singles d b) (i:Grid) :
-    funds f.amp i=(f.amp ⟨i,(0:Fin 1)⟩).2 := by
-  unfold funds
-  let : Unique (Fin (singles i)) := (show Unique (Fin 1) from inferInstance)
-  exact Fintype.sum_unique _
-
-theorem fourPens (s:Plan p n) (K:ℕ) (H : Stalls p) (h:booths p K s H)
-    (ht : 2*frameBills p.g K+4 ≤Fintype.card (Label p.b)) :
-    ∃ z:Messenger singles→Label p.b, Injective z ∧ ∀ i j, z i∉ H j := by
-  classical
-  let F:=H true ∪ H false; let T:=Fᶜ
-  have hp : F.card≤ 2* frameBills p.g K :=
-    (Finset.card_union_le _ _).trans ((add_le_add (h.1 _) (h.1 _)).trans_eq (two_mul _).symm)
-  have he : Fintype.card (Messenger singles) ≤ Fintype.card (↑T:Type) := by
-    rw [Fintype.card_coe,singles_card]; unfold T; rw [Finset.card_compl]; omega
-  obtain ⟨i,hi⟩: ∃ i : Messenger singles → ↑T,Injective i := by
-
-    obtain ⟨g⟩:=Function.Embedding.nonempty_of_card_le he
-    exact ⟨g,g.injective⟩
-  refine ⟨fun x=>(i x).val,Subtype.val_injective.comp hi,fun x b=>?_⟩
-  have hh:(i x).val∉F:=Finset.mem_compl.mp (i x).property
-  intro hx; cases b
-  · exact hh (Finset.mem_union_right _ hx)
-  exact hh (Finset.mem_union_left _ hx)
-
-variable {d:Rates}
-def coordSpec (m:BMark p n N) (o:UnitType p n N) (s:Charts p n d)
-    (w:∀ i:Nodes,Cell (d i)) := ∀ i,s i (w i)= m o i
-
-def beacon (p:Shape) (s:Charts p n d) (w:∀ i:Nodes,Cell (d i)) (b:Bool)
-    (T: Cross p n) (z : Digest p.g) : Amounts p singles d b :=
-   fun k =>
-     let i:=parcel b k
-     let j:= parcel (!b) k
-     let x:=targetMark p s T i j
-     (z,(z.diagO,x), z.diagO+dotProduct x (w i))
-
-set_option maxHeartbeats 800000 in
-theorem stillBeacon (m:BMark p n N) (o:UnitType p n N) (s:Charts p n d)
-    (w:∀ i:Nodes,Cell (d i)) (b:Bool) (T:Cross p n) (z:Digest p.g)
-    (h:coordSpec m o s w) (hT:∀ i,cardTone m o T i= glint p (m o)) :
-    still b (beacon p s w b T z) s T := by
-  classical
-  let f:Amounts p singles d b:= beacon p s w b T z
-  have hf (i): funds f i=(f ⟨i,(0:Fin 1)⟩).2 := by
-    unfold funds; let : Unique (Fin (singles i)) := (show Unique (Fin 1) from inferInstance); exact Fintype.sum_unique _
-  change (∀ i, _ ) ∧ _
-  constructor
-  · intro i
-    change (funds f i).1.2=_
-    rw [hf]
-    rfl
-  intro i
-  have hh t q : couple _ (funds f (transit b (t,q))) =
-      contract p T t q (m o t)+role p n (m o t) := by
-    rw [hf]
-    let k : Messenger singles:=⟨transit b (t,q),(0:Fin 1)⟩
-    let a:= targetMark p s T (parcel b k) (parcel (!b) k)
-    change z.diagO+(z.diagO+dotProduct a (w _))=_
-    rw [← add_assoc,char_two,zero_add]; unfold a targetMark
-    rw [← roll_project]
-    have he (i t): (contract p T i t+role p n) (s i (w i))=contract p T i t (m o i)+role p n (m o i) :=
-      by rw [h]; rfl
-    rw [he]; cases b <;> rfl
-  change couple _ (funds f _) = couple _ (funds f _)
-  simp_rw [hh]
-  have ht:= hT i
-  unfold glint cardTone at ht; rw [Fintype.sum_bool,Fintype.sum_bool] at ht
-  apply sub_eq_zero.mp
-  rw [ZModModule.sub_eq_add]
-  rw [add_add_add_comm,ht,char_two]
-
-set_option maxHeartbeats 700000 in
-theorem steadyBeacon {plan : Plan p n} (m:BMark p n N) (o:UnitType p n N) (s:Charts p n d)
-    (w:∀ i:Nodes,Cell (d i)) (b:Bool) (T:Cross p n)
-    (q:Quill p singles d b) (t:Tagging p (Messenger singles))
-    (g: Mixer p n) (z:Digest p.g) (K:ℕ)
-    (hd:∀ i,d i≤K^2)
-    (ha:q.amp=beacon p s w b T z)
-    (hk:planRank plan≤K)
-    (hs:charted s plan)
-    (h:coordSpec m o s w)
-    (hF : PreparationParameters.frameSide p g o)
-    (hg : exactInk p g m o) :
-    q.steady t (fun _=>1) g K s o := by
-  classical
-  refine ⟨hF,fun i=> ⟨hd _,(hs _).2,fun y=>?_⟩,fun i=>by rw [ha];rfl, fun i v hv => ?_⟩
-  · refine (effective_rank (i:=parcel b i) ?_).trans hk
-    rw [← (hs _).1]; exact mem_range_self _ _
-  · let l:= q.allure t (fun _=>1) i; let j:=parcel b i
-    let V:= l.profile j o g (s j) v
-    have ht : V.1 = (q.amp i).1 ∧ V.2.1=(q.amp i).2.1 → V=q.amp i := by
-      rintro ⟨h1,h2⟩
-      apply Prod.ext h1 (Prod.ext h2 _)
-      rw [ha] at h2 ⊢
-      let a:= useAtom p l.l l.s l.f v
-      let k:=targetMark p s T j (parcel (!b) i)
-      have heq : V.2.2 = z.diagO + dotProduct k (w j) := by
-        have he := exactInner g m o hg j a
-        have hx : a∈Xspace p n:= mem_useAtom ..
-        have hg' : role p n a=z.diagO := congrArg Prod.fst h2
-        have hk : roll (s j) (Tsym g a)=k := congrArg Prod.snd h2
-        change innerP p o j a=_
-        rw [he hx, grad_val,hg',T_swap, ←h,roll_project,hk]
-      exact heq
-    exact (hv ht).elim
-
-end StatusAnalysis
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.CompatibleOptionRealization
+
+namespace OAI
+
+/-! # Rare Test Events -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Filter Finset Matrix LinearMap Module Function
+open scoped BigOperators Topology
+variable {p:Shape} {n N K M : ℕ}
+namespace StatusAnalysis
+
+def singles : Format:=fun _=>1
+def volume1 : Volumes:=fun _=>1
+theorem singles_vol : singles=toFormat volume1 := rfl
+theorem singles_card : Fintype.card (Messenger singles)=4 := by
+  decide
+theorem singles_short : ∀ i,1≤singles i ∧ singles i≤7 :=by simp [singles]
+theorem funds_one {b : Bool} {d : Rates} (f: Fabric p singles d b) (i:Grid) :
+    funds f.amp i=(f.amp ⟨i,(0:Fin 1)⟩).2 := by
+  unfold funds
+  let : Unique (Fin (singles i)) := (show Unique (Fin 1) from inferInstance)
+  exact Fintype.sum_unique _
+
+theorem fourPens (s:Plan p n) (K:ℕ) (H : Stalls p) (h:booths p K s H)
+    (ht : 2*frameBills p.g K+4 ≤Fintype.card (Label p.b)) :
+    ∃ z:Messenger singles→Label p.b, Injective z ∧ ∀ i j, z i∉ H j := by
+  classical
+  let F:=H true ∪ H false; let T:=Fᶜ
+  have hp : F.card≤ 2* frameBills p.g K :=
+    (Finset.card_union_le _ _).trans ((add_le_add (h.1 _) (h.1 _)).trans_eq (two_mul _).symm)
+  have he : Fintype.card (Messenger singles) ≤ Fintype.card (↑T:Type) := by
+    rw [Fintype.card_coe,singles_card]; unfold T; rw [Finset.card_compl]; omega
+  obtain ⟨i,hi⟩: ∃ i : Messenger singles → ↑T,Injective i := by
+
+    obtain ⟨g⟩:=Function.Embedding.nonempty_of_card_le he
+    exact ⟨g,g.injective⟩
+  refine ⟨fun x=>(i x).val,Subtype.val_injective.comp hi,fun x b=>?_⟩
+  have hh:(i x).val∉F:=Finset.mem_compl.mp (i x).property
+  intro hx; cases b
+  · exact hh (Finset.mem_union_right _ hx)
+  exact hh (Finset.mem_union_left _ hx)
+
+variable {d:Rates}
+def coordSpec (m:BMark p n N) (o:UnitType p n N) (s:Charts p n d)
+    (w:∀ i:Nodes,Cell (d i)) := ∀ i,s i (w i)= m o i
+
+def beacon (p:Shape) (s:Charts p n d) (w:∀ i:Nodes,Cell (d i)) (b:Bool)
+    (T: Cross p n) (z : Digest p.g) : Amounts p singles d b :=
+   fun k =>
+     let i:=parcel b k
+     let j:= parcel (!b) k
+     let x:=targetMark p s T i j
+     (z,(z.diagO,x), z.diagO+dotProduct x (w i))
+
+set_option maxHeartbeats 800000 in
+theorem stillBeacon (m:BMark p n N) (o:UnitType p n N) (s:Charts p n d)
+    (w:∀ i:Nodes,Cell (d i)) (b:Bool) (T:Cross p n) (z:Digest p.g)
+    (h:coordSpec m o s w) (hT:∀ i,cardTone m o T i= glint p (m o)) :
+    still b (beacon p s w b T z) s T := by
+  classical
+  let f:Amounts p singles d b:= beacon p s w b T z
+  have hf (i): funds f i=(f ⟨i,(0:Fin 1)⟩).2 := by
+    unfold funds; let : Unique (Fin (singles i)) := (show Unique (Fin 1) from inferInstance); exact Fintype.sum_unique _
+  change (∀ i, _ ) ∧ _
+  constructor
+  · intro i
+    change (funds f i).1.2=_
+    rw [hf]
+    rfl
+  intro i
+  have hh t q : couple _ (funds f (transit b (t,q))) =
+      contract p T t q (m o t)+role p n (m o t) := by
+    rw [hf]
+    let k : Messenger singles:=⟨transit b (t,q),(0:Fin 1)⟩
+    let a:= targetMark p s T (parcel b k) (parcel (!b) k)
+    change z.diagO+(z.diagO+dotProduct a (w _))=_
+    rw [← add_assoc,char_two,zero_add]; unfold a targetMark
+    rw [← roll_project]
+    have he (i t): (contract p T i t+role p n) (s i (w i))=contract p T i t (m o i)+role p n (m o i) :=
+      by rw [h]; rfl
+    rw [he]; cases b <;> rfl
+  change couple _ (funds f _) = couple _ (funds f _)
+  simp_rw [hh]
+  have ht:= hT i
+  unfold glint cardTone at ht; rw [Fintype.sum_bool,Fintype.sum_bool] at ht
+  apply sub_eq_zero.mp
+  rw [ZModModule.sub_eq_add]
+  rw [add_add_add_comm,ht,char_two]
+
+set_option maxHeartbeats 700000 in
+theorem steadyBeacon {plan : Plan p n} (m:BMark p n N) (o:UnitType p n N) (s:Charts p n d)
+    (w:∀ i:Nodes,Cell (d i)) (b:Bool) (T:Cross p n)
+    (q:Quill p singles d b) (t:Tagging p (Messenger singles))
+    (g: Mixer p n) (z:Digest p.g) (K:ℕ)
+    (hd:∀ i,d i≤K^2)
+    (ha:q.amp=beacon p s w b T z)
+    (hk:planRank plan≤K)
+    (hs:charted s plan)
+    (h:coordSpec m o s w)
+    (hF : PreparationParameters.frameSide p g o)
+    (hg : exactInk p g m o) :
+    q.steady t (fun _=>1) g K s o := by
+  classical
+  refine ⟨hF,fun i=> ⟨hd _,(hs _).2,fun y=>?_⟩,fun i=>by rw [ha];rfl, fun i v hv => ?_⟩
+  · refine (effective_rank (i:=parcel b i) ?_).trans hk
+    rw [← (hs _).1]; exact mem_range_self _ _
+  · let l:= q.allure t (fun _=>1) i; let j:=parcel b i
+    let V:= l.profile j o g (s j) v
+    have ht : V.1 = (q.amp i).1 ∧ V.2.1=(q.amp i).2.1 → V=q.amp i := by
+      rintro ⟨h1,h2⟩
+      apply Prod.ext h1 (Prod.ext h2 _)
+      rw [ha] at h2 ⊢
+      let a:= useAtom p l.l l.s l.f v
+      let k:=targetMark p s T j (parcel (!b) i)
+      have heq : V.2.2 = z.diagO + dotProduct k (w j) := by
+        have he := exactInner g m o hg j a
+        have hx : a∈Xspace p n:= mem_useAtom ..
+        have hg' : role p n a=z.diagO := congrArg Prod.fst h2
+        have hk : roll (s j) (Tsym g a)=k := congrArg Prod.snd h2
+        change innerP p o j a=_
+        rw [he hx, grad_val,hg',T_swap, ←h,roll_project,hk]
+      exact heq
+    exact (hv ht).elim
+
+end StatusAnalysis
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/RawFrameLaws.lean

@@ -1,185 +1,185 @@
-import OAI.Combinatorics.HadwigerCounterexample.AffineFrames
-import OAI.Combinatorics.HadwigerCounterexample.MixedImageBounds
-
-namespace OAI
-
-/-! # Raw Frame Laws -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Matrix
-open scoped BigOperators
-
-variable {p : Shape} {n N : ℕ}
-
-instance rowDecidableEq (p : Shape) (n : ℕ) : DecidableEq (Row p n) := inferInstance
-instance fullDecidableEq (p : Shape) (n : ℕ) : DecidableEq (Full p n) := inferInstance
-instance fullFintype (p : Shape) (n : ℕ) : Fintype (Full p n) := inferInstance
-instance oframeFintype (p : Shape) (n N : ℕ) : Fintype (Oframe p n N) := inferInstance
-instance orientFintype (p : Shape) (n N : ℕ) : Fintype (Orient p n N) := inferInstance
-
-def gramCond (m : Mixer p n) (G : Mat (Full p n) (Full p n)) : Prop :=
-  G.toBlocks₁₁ = selfM p n m.mixM ∧ G.toBlocks₂₁ = 0 ∧ G.toBlocks₁₂ = 0
-
-theorem gramCond_exists (m : Mixer p n) : ∃ G, gramCond m G := by
-  refine ⟨fromBlocks (selfM p n m.mixM) 0 0 0,?_,?_,?_⟩ <;> rfl
-
-theorem valid_iff (m : Mixer p n) (X : Oframe p n N) :
-    valid (selfM p n m.mixM) X ↔ FramesAt (gramCond m) X := by
-  have he : (X.1ᵀ*X.2).toBlocks₁₁ = (primary X.1)ᵀ * primary X.2 := by ext; rfl
-  have hf : (X.1ᵀ*X.2).toBlocks₂₁ = (channel X.1)ᵀ * primary X.2 := by ext; rfl
-  have hg : (X.1ᵀ*X.2).toBlocks₁₂ = (primary X.1)ᵀ * channel X.2 := by ext; rfl
-  unfold valid FramesAt gramCond
-  rw [he,hf,hg]; tauto
-
-def raw (m : Mixer p n) (N : ℕ) : Wgt (Orient p n N) :=
-  prodW (fun (_ : Comp p.g) => unifOn (FramesAt (U := Fin N) (gramCond m)))
-
-theorem raw_law (m : Mixer p n) (hN : 2*num (Full p n)<N) : IsLaw (raw m N) :=
-  prodW_law (fun _ => unifOn_law (framesAt_exists (gramCond_exists m)
-    (show num (Full p n) + num (Full p n) < num (Fin N) by
-      rw [← two_mul]; simpa [num] using hN)))
-
-theorem raw_nonneg (m : Mixer p n) (X : Orient p n N) : 0 ≤ raw m N X :=
-  prodW_nonneg (fun _ _ => (unifOn_sub _).nz _) _
-
-theorem raw_carried (m : Mixer p n) (N : ℕ) : carried (raw m N) (frameLaw m) := by
-  intro X h
-  unfold frameLaw at h
-  push Not at h
-  obtain ⟨e,he⟩ := h
-  unfold raw prodW
-  apply Finset.prod_eq_zero (Finset.mem_univ e)
-  exact unifOn_carried _ _ ((valid_iff _ _).not.mp he)
-
-abbrev UnitType (p : Shape) (n N : ℕ) := Orient p n N × Orient p n N
-abbrev Place (p : Shape) := Comp p.g × Bool
-abbrev JointIdx (p : Shape) (n : ℕ) := Full p n ⊕ Full p n
-
-def takeSign (w : Oframe p n N) (b : Bool) := if b then w.1 else w.2
-
-def images (x : UnitType p n N) (z : Place p) : Mat (Fin N) (JointIdx p n) :=
-  fromCols (takeSign (x.1 z.1) z.2) (takeSign (x.2 z.1) z.2)
-
-abbrev Dir (p : Shape) (n : ℕ) := Vec (JointIdx p n)
-abbrev Plan (p : Shape) (n : ℕ) := Place p → Submodule F (Dir p n)
-def planRank (s : Plan p n) := ∑ i, dim (s i)
-
-/-- Pin data: stored subspaces of directions with assigned images. We store a
-full linear map for convenience; only its restriction to the pin directions
-at each place is used. Counts charge only for the restrictions. -/
-structure Pin (p : Shape) (n N : ℕ) where
-  sp : Plan p n
-  target : Place p → Mat (Fin N) (JointIdx p n)
-
-def Pin.agree (a : Pin p n N) (x : UnitType p n N) :=
-  ∀ i, ∀ v ∈ a.sp i, images x i *ᵥ v = a.target i *ᵥ v
-
-theorem Pin.agree_pack {a : Pin p n N} {x : UnitType p n N} :
-    a.agree x ↔ ∀ i : Place p, images x i * pack (a.sp i) = a.target i * pack (a.sp i) := by
-  have heq {I J L : Type} [Fintype I] [Fintype J] [Fintype L] (P Q : Mat I J) (M : Mat J L) :
-      (∀ v ∈ colSp M, P *ᵥ v = Q *ᵥ v) ↔ P*M=Q*M := by
-    constructor
-    · intro h
-      apply coe_mv_inj
-      exact LinearMap.ext fun v => by
-        change (P*M) *ᵥ v=(Q*M) *ᵥ v
-        rw [← mulVec_mulVec,← mulVec_mulVec]
-        exact h _ ⟨v,rfl⟩
-    · rintro h x ⟨v,rfl⟩
-      change P *ᵥ (M *ᵥ v) = Q *ᵥ (M *ᵥ v)
-      rw [mulVec_mulVec,mulVec_mulVec,h]
-  unfold Pin.agree
-  apply forall_congr'; intro i
-  have hh := heq (images x i) (a.target i) (pack (a.sp i))
-  rw [colSp_pack] at hh
-  exact hh
-
-theorem bp_sum {A : Type*} (s : Finset A) (f : A → ℝ) :
-    bp (∑ i ∈ s, f i) = ∏ i ∈ s, bp (f i) := by
-  classical
-  induction s using Finset.induction with
-  | empty => simp
-  | insert a s ha hi => rw [Finset.sum_insert ha, Finset.prod_insert ha,bp_add,hi]
-
-/-- Image cap under two independent raw orientations. Uniform over all
-simultaneous exact-image specifications. -/
-theorem reference_cap (m : Mixer p n) (a : Pin p n N) {δ : ℝ} (hd : 0 < δ)
-    (hu : 2*num (Full p n) - N ≤ -1)
-    (hδ : 2*num (Full p n) ≤ δ/2 * N)
-    (hA : 4*num (Comp p.g) ≤ δ/2 * N) :
-    pr (pairW (raw m N) (raw m N)) a.agree ≤ bp (-(1-δ)*(planRank a.sp)*N) := by
-  let s := a.sp
-  let μ := raw m N
-  have hn : 2*num (Full p n)<N := by linarith only [hu]
-  have hh := raw_law m hn
-  by_cases he : planRank s = 0
-  · change _ ≤ bp (_ * (planRank s) * _)
-    rw [he]
-    simp only [Nat.cast_zero,mul_zero,zero_mul,bp_zero]
-    exact le_trans (pr_le_tot (pairW_law hh hh).nz) (pairW_law hh hh).total.le
-  let g (e : Comp p.g) := unifOn (FramesAt (U:=Fin N) (gramCond m))
-  let D (e : Place p) := pack (s e)
-  let rankval (e : Place p) := (dim (s e) : ℝ)
-  let f (e : Comp p.g) (w : Oframe p n N × Oframe p n N) :=
-    mixImage (D (e,true)) (w.1.1,w.2.1) = a.target (e,true) * D (e,true) ∧
-    mixImage (D (e,false)) (w.1.2,w.2.2) = a.target (e,false) * D (e,false)
-  have hf : pr (pairW μ μ) a.agree = ∏ e, pr (pairW (g e) (g e)) (f e) := by
-    have hfun : a.agree = (fun x => ∀ e, f e (x.1 e,x.2 e)) := by
-      funext x; apply propext
-      rw [Pin.agree_pack]
-      constructor
-      · intro hi e
-        exact ⟨hi (e,true),hi (e,false)⟩
-      · rintro h ⟨e,b⟩; cases b
-        · exact (h e).2
-        · exact (h e).1
-    rw [hfun]
-    exact prodW_pair_pr g g f
-  let y := fun e : Comp p.g => 4 - (1-δ/2) * (rankval (e,true)+rankval (e,false))*N
-  have hb (e) : pr (pairW (g e) (g e)) (f e) ≤ bp (y e) := by
-    have h1 := comp_image_cap (gramCond_exists m)
-      (show 2*num (Full p n)-num (Fin N) ≤ -1 by simpa [num] using hu)
-      _ _ (pack_inj (s (e,true))) (pack_inj (s (e,false))) (a.target (e,true)*D (e,true))
-      (a.target (e,false)*D (e,false))
-    have hnum (n : ℕ) : num (Fin n)=(n:ℝ) := by simp [num]
-    change pr _ _ ≤ _
-    apply le_trans h1
-    rw [show (16:ℝ)=bp 4 by
-      have hh := bp_nat 4; norm_num at hh ⊢; linarith,← bp_add,hnum,hnum,hnum]
-    apply bp_le
-    let rp := rankval (e,true)
-    let rm := rankval (e,false)
-    change 4+(-((N:ℝ))*rp-(_-2*num (Full p n))*rm) ≤ 4 - _ * (rp+rm)*_
-    have hp := mul_nonneg (show 0 ≤ rp from Nat.cast_nonneg _) (mul_nonneg hd.le
-      (show (0:ℝ) ≤ N from Nat.cast_nonneg _))
-    have hg := mul_le_mul_of_nonneg_right hδ (show 0 ≤ rm from Nat.cast_nonneg _)
-    linarith only [hp,hg]
-  have hg : pr (pairW μ μ) a.agree ≤ bp (∑ i, y i) := by
-    rw [hf,bp_sum]
-    apply Finset.prod_le_prod₀ _ fun i _ => hb i
-    exact fun i _ => pr_nonneg
-      (subLaw_pair (unifOn_sub _) (unifOn_sub _)).nz
-  apply hg.trans
-  apply bp_le
-  have ht : (planRank s : ℝ) = ∑ i : Comp p.g, (rankval (i,true) + rankval (i,false)) := by
-    rw [planRank,Fintype.sum_prod_type]
-    simp only [Fintype.sum_bool, Nat.cast_sum,Nat.cast_add,rankval]
-  have h1 : ∑ i, y i = 4*num (Comp p.g) - (1-δ/2)*(planRank s)*N := by
-    dsimp only [y]
-    rw [Finset.sum_sub_distrib,← Finset.sum_mul, ← Finset.mul_sum, ← ht]
-    simp only [Finset.sum_const,Finset.card_univ,nsmul_eq_mul,num]
-    ring
-  have hk : 1 ≤ (planRank s : ℝ) := by
-    exact_mod_cast Nat.one_le_iff_ne_zero.mpr he
-  rw [h1]
-  change _ ≤ -(1-δ)*(planRank s)*N
-  have he := mul_le_mul_of_nonneg_right hk
-    (mul_nonneg hd.le (show (0:ℝ) ≤ N from Nat.cast_nonneg _))
-  linarith only [hA,he]
-
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.AffineFrames
+import OAI.Combinatorics.HadwigerCounterexample.MixedImageBounds
+
+namespace OAI
+
+/-! # Raw Frame Laws -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Matrix
+open scoped BigOperators
+
+variable {p : Shape} {n N : ℕ}
+
+instance rowDecidableEq (p : Shape) (n : ℕ) : DecidableEq (Row p n) := inferInstance
+instance fullDecidableEq (p : Shape) (n : ℕ) : DecidableEq (Full p n) := inferInstance
+instance fullFintype (p : Shape) (n : ℕ) : Fintype (Full p n) := inferInstance
+instance oframeFintype (p : Shape) (n N : ℕ) : Fintype (Oframe p n N) := inferInstance
+instance orientFintype (p : Shape) (n N : ℕ) : Fintype (Orient p n N) := inferInstance
+
+def gramCond (m : Mixer p n) (G : Mat (Full p n) (Full p n)) : Prop :=
+  G.toBlocks₁₁ = selfM p n m.mixM ∧ G.toBlocks₂₁ = 0 ∧ G.toBlocks₁₂ = 0
+
+theorem gramCond_exists (m : Mixer p n) : ∃ G, gramCond m G := by
+  refine ⟨fromBlocks (selfM p n m.mixM) 0 0 0,?_,?_,?_⟩ <;> rfl
+
+theorem valid_iff (m : Mixer p n) (X : Oframe p n N) :
+    valid (selfM p n m.mixM) X ↔ FramesAt (gramCond m) X := by
+  have he : (X.1ᵀ*X.2).toBlocks₁₁ = (primary X.1)ᵀ * primary X.2 := by ext; rfl
+  have hf : (X.1ᵀ*X.2).toBlocks₂₁ = (channel X.1)ᵀ * primary X.2 := by ext; rfl
+  have hg : (X.1ᵀ*X.2).toBlocks₁₂ = (primary X.1)ᵀ * channel X.2 := by ext; rfl
+  unfold valid FramesAt gramCond
+  rw [he,hf,hg]; tauto
+
+def raw (m : Mixer p n) (N : ℕ) : Wgt (Orient p n N) :=
+  prodW (fun (_ : Comp p.g) => unifOn (FramesAt (U := Fin N) (gramCond m)))
+
+theorem raw_law (m : Mixer p n) (hN : 2*num (Full p n)<N) : IsLaw (raw m N) :=
+  prodW_law (fun _ => unifOn_law (framesAt_exists (gramCond_exists m)
+    (show num (Full p n) + num (Full p n) < num (Fin N) by
+      rw [← two_mul]; simpa [num] using hN)))
+
+theorem raw_nonneg (m : Mixer p n) (X : Orient p n N) : 0 ≤ raw m N X :=
+  prodW_nonneg (fun _ _ => (unifOn_sub _).nz _) _
+
+theorem raw_carried (m : Mixer p n) (N : ℕ) : carried (raw m N) (frameLaw m) := by
+  intro X h
+  unfold frameLaw at h
+  push Not at h
+  obtain ⟨e,he⟩ := h
+  unfold raw prodW
+  apply Finset.prod_eq_zero (Finset.mem_univ e)
+  exact unifOn_carried _ _ ((valid_iff _ _).not.mp he)
+
+abbrev UnitType (p : Shape) (n N : ℕ) := Orient p n N × Orient p n N
+abbrev Place (p : Shape) := Comp p.g × Bool
+abbrev JointIdx (p : Shape) (n : ℕ) := Full p n ⊕ Full p n
+
+def takeSign (w : Oframe p n N) (b : Bool) := if b then w.1 else w.2
+
+def images (x : UnitType p n N) (z : Place p) : Mat (Fin N) (JointIdx p n) :=
+  fromCols (takeSign (x.1 z.1) z.2) (takeSign (x.2 z.1) z.2)
+
+abbrev Dir (p : Shape) (n : ℕ) := Vec (JointIdx p n)
+abbrev Plan (p : Shape) (n : ℕ) := Place p → Submodule F (Dir p n)
+def planRank (s : Plan p n) := ∑ i, dim (s i)
+
+/-- Pin data: stored subspaces of directions with assigned images. We store a
+full linear map for convenience; only its restriction to the pin directions
+at each place is used. Counts charge only for the restrictions. -/
+structure Pin (p : Shape) (n N : ℕ) where
+  sp : Plan p n
+  target : Place p → Mat (Fin N) (JointIdx p n)
+
+def Pin.agree (a : Pin p n N) (x : UnitType p n N) :=
+  ∀ i, ∀ v ∈ a.sp i, images x i *ᵥ v = a.target i *ᵥ v
+
+theorem Pin.agree_pack {a : Pin p n N} {x : UnitType p n N} :
+    a.agree x ↔ ∀ i : Place p, images x i * pack (a.sp i) = a.target i * pack (a.sp i) := by
+  have heq {I J L : Type} [Fintype I] [Fintype J] [Fintype L] (P Q : Mat I J) (M : Mat J L) :
+      (∀ v ∈ colSp M, P *ᵥ v = Q *ᵥ v) ↔ P*M=Q*M := by
+    constructor
+    · intro h
+      apply coe_mv_inj
+      exact LinearMap.ext fun v => by
+        change (P*M) *ᵥ v=(Q*M) *ᵥ v
+        rw [← mulVec_mulVec,← mulVec_mulVec]
+        exact h _ ⟨v,rfl⟩
+    · rintro h x ⟨v,rfl⟩
+      change P *ᵥ (M *ᵥ v) = Q *ᵥ (M *ᵥ v)
+      rw [mulVec_mulVec,mulVec_mulVec,h]
+  unfold Pin.agree
+  apply forall_congr'; intro i
+  have hh := heq (images x i) (a.target i) (pack (a.sp i))
+  rw [colSp_pack] at hh
+  exact hh
+
+theorem bp_sum {A : Type*} (s : Finset A) (f : A → ℝ) :
+    bp (∑ i ∈ s, f i) = ∏ i ∈ s, bp (f i) := by
+  classical
+  induction s using Finset.induction with
+  | empty => simp
+  | insert a s ha hi => rw [Finset.sum_insert ha, Finset.prod_insert ha,bp_add,hi]
+
+/-- Image cap under two independent raw orientations. Uniform over all
+simultaneous exact-image specifications. -/
+theorem reference_cap (m : Mixer p n) (a : Pin p n N) {δ : ℝ} (hd : 0 < δ)
+    (hu : 2*num (Full p n) - N ≤ -1)
+    (hδ : 2*num (Full p n) ≤ δ/2 * N)
+    (hA : 4*num (Comp p.g) ≤ δ/2 * N) :
+    pr (pairW (raw m N) (raw m N)) a.agree ≤ bp (-(1-δ)*(planRank a.sp)*N) := by
+  let s := a.sp
+  let μ := raw m N
+  have hn : 2*num (Full p n)<N := by linarith only [hu]
+  have hh := raw_law m hn
+  by_cases he : planRank s = 0
+  · change _ ≤ bp (_ * (planRank s) * _)
+    rw [he]
+    simp only [Nat.cast_zero,mul_zero,zero_mul,bp_zero]
+    exact le_trans (pr_le_tot (pairW_law hh hh).nz) (pairW_law hh hh).total.le
+  let g (e : Comp p.g) := unifOn (FramesAt (U:=Fin N) (gramCond m))
+  let D (e : Place p) := pack (s e)
+  let rankval (e : Place p) := (dim (s e) : ℝ)
+  let f (e : Comp p.g) (w : Oframe p n N × Oframe p n N) :=
+    mixImage (D (e,true)) (w.1.1,w.2.1) = a.target (e,true) * D (e,true) ∧
+    mixImage (D (e,false)) (w.1.2,w.2.2) = a.target (e,false) * D (e,false)
+  have hf : pr (pairW μ μ) a.agree = ∏ e, pr (pairW (g e) (g e)) (f e) := by
+    have hfun : a.agree = (fun x => ∀ e, f e (x.1 e,x.2 e)) := by
+      funext x; apply propext
+      rw [Pin.agree_pack]
+      constructor
+      · intro hi e
+        exact ⟨hi (e,true),hi (e,false)⟩
+      · rintro h ⟨e,b⟩; cases b
+        · exact (h e).2
+        · exact (h e).1
+    rw [hfun]
+    exact prodW_pair_pr g g f
+  let y := fun e : Comp p.g => 4 - (1-δ/2) * (rankval (e,true)+rankval (e,false))*N
+  have hb (e) : pr (pairW (g e) (g e)) (f e) ≤ bp (y e) := by
+    have h1 := comp_image_cap (gramCond_exists m)
+      (show 2*num (Full p n)-num (Fin N) ≤ -1 by simpa [num] using hu)
+      _ _ (pack_inj (s (e,true))) (pack_inj (s (e,false))) (a.target (e,true)*D (e,true))
+      (a.target (e,false)*D (e,false))
+    have hnum (n : ℕ) : num (Fin n)=(n:ℝ) := by simp [num]
+    change pr _ _ ≤ _
+    apply le_trans h1
+    rw [show (16:ℝ)=bp 4 by
+      have hh := bp_nat 4; norm_num at hh ⊢; linarith,← bp_add,hnum,hnum,hnum]
+    apply bp_le
+    let rp := rankval (e,true)
+    let rm := rankval (e,false)
+    change 4+(-((N:ℝ))*rp-(_-2*num (Full p n))*rm) ≤ 4 - _ * (rp+rm)*_
+    have hp := mul_nonneg (show 0 ≤ rp from Nat.cast_nonneg _) (mul_nonneg hd.le
+      (show (0:ℝ) ≤ N from Nat.cast_nonneg _))
+    have hg := mul_le_mul_of_nonneg_right hδ (show 0 ≤ rm from Nat.cast_nonneg _)
+    linarith only [hp,hg]
+  have hg : pr (pairW μ μ) a.agree ≤ bp (∑ i, y i) := by
+    rw [hf,bp_sum]
+    apply Finset.prod_le_prod₀ _ fun i _ => hb i
+    exact fun i _ => pr_nonneg
+      (subLaw_pair (unifOn_sub _) (unifOn_sub _)).nz
+  apply hg.trans
+  apply bp_le
+  have ht : (planRank s : ℝ) = ∑ i : Comp p.g, (rankval (i,true) + rankval (i,false)) := by
+    rw [planRank,Fintype.sum_prod_type]
+    simp only [Fintype.sum_bool, Nat.cast_sum,Nat.cast_add,rankval]
+  have h1 : ∑ i, y i = 4*num (Comp p.g) - (1-δ/2)*(planRank s)*N := by
+    dsimp only [y]
+    rw [Finset.sum_sub_distrib,← Finset.sum_mul, ← Finset.mul_sum, ← ht]
+    simp only [Finset.sum_const,Finset.card_univ,nsmul_eq_mul,num]
+    ring
+  have hk : 1 ≤ (planRank s : ℝ) := by
+    exact_mod_cast Nat.one_le_iff_ne_zero.mpr he
+  rw [h1]
+  change _ ≤ -(1-δ)*(planRank s)*N
+  have he := mul_le_mul_of_nonneg_right hk
+    (mul_nonneg hd.le (show (0:ℝ) ≤ N from Nat.cast_nonneg _))
+  linarith only [hA,he]
+
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/RealizationConditions.lean

@@ -1,93 +1,93 @@
-import OAI.Combinatorics.HadwigerCounterexample.KeyDirections
-
-namespace OAI
-
-/-! # Realization Conditions -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Matrix
-open scoped BigOperators
-variable {p : Shape} {n N : ℕ} {I : Type} [Fintype I]
-
-namespace Volley
-variable (v w : Volley p n I)
-
-def legal (t : Tagging p I) := ∀ i : I, allows (t i) (v.par i)
-def diagonalAt (i : I) := eta p n (mom p (v.sel i) (v.par i))
-def bounded (w' : I→Bool) := ∀ (i j : Bool), 1≤ (v.shoots w' i j).card ∧
-    (v.shoots w' i j).card ≤7
-
-/-- Conditions for one orientation of roles, §5 (scalar recipe). -/
-structure scalarRecipe (t : Tagging p I) (m : Mixer p n) (x : UnitType p n N) (S : Plan p n)
-    (M : Cross p n) : Prop where
-  summ (i j : Bool) : ∑ a ∈ v.shoots w.obj i j,v.diagonalAt a=1
-  coupled (j : Bool) : ((innerP p x true)+role p n) (v.sumAt t w.obj true j) =
-    ((innerP p x false)+role p n) (v.sumAt t w.obj false j)
-  gradient (i j : Bool) (y : Profile p n) : y∈effective S i →
-    grad m (v.sumAt t w.obj i j) y= contract p M i j y
-
-def roleMatch (t : Tagging p I) :=
-  ∀ i j, role p n (v.sumAt t w.obj i j)+ role p n (w.sumAt t v.obj j i)=1
-
-def attackGrad (t : Tagging p I) (m : Mixer p n) (y : UnitType p n N) :=
-  ∀ (a : I) (j : Bool),
-    grad m (v.sumAt t w.obj (v.obj a) j) (v.atomAt t a) =
-      if j=w.obj a then 0 else innerP p y (w.obj a) (w.atomAt t a)
-
-def realized (t : Tagging p I) (m : Mixer p n) (M : Cross p n) :=
-  ∀ i j, ∀ y ∈ Xspace p n, grad m (v.sumAt t w.obj i j) y=contract p M i j y
-
-theorem shoots_swap (i j) : v.shoots w.obj i j=w.shoots v.obj j i := by
-  ext; simp [shoots,and_comm]
-
-theorem sum_share {t : Tagging p I} {x y : UnitType p n N} (h : v.keys t x=w.keys t y)
-    (i j : Bool) : Uembed (onSide x i) (v.sumAt t w.obj i j)=
-      Uembed (onSide y j) (w.sumAt t v.obj j i) := by
-  classical
-  unfold sumAt
-  rw [map_sum,map_sum,← shoots_swap v w]
-  refine Finset.sum_congr rfl fun k hk => ?_
-  have hi := (Finset.mem_filter.mp hk).2
-  rw [← hi.1, ← hi.2]
-  exact v.atom_share _ _ _ _ h k
-
-theorem sum_mem {t : Tagging p I} (h : v.legal t) (f : I → Bool) (i j : Bool) :
-    v.sumAt t f i j∈Xspace p n :=
-  Submodule.sum_mem _ fun k _ => atom_mem _ (h k)
-
-theorem realized_conflicts {t : Tagging p I} (m : Mixer p n)
-    (x y : UnitType p n N) (hv : v.legal t) (hw : w.legal t)
-    (hL : ∀ i, frameLaw m (onSide x i)) (hR : ∀ i, frameLaw m (onSide y i))
-    (h : v.keys t x=w.keys t y) (hm : v.roleMatch w t)
-    (hA : v.realized w t m (actual p x y)) (hB : w.realized v t m (actual p y x)) :
-    (rawHoles m).conflict x y := by
-  have hh i j : hole m (onSide x i) (onSide y j) := by
-    refine ⟨hL i,hR j,v.sumAt t w.obj i j,w.sumAt t v.obj j i,
-      v.sum_mem hv .., w.sum_mem hw .., v.sum_share _ h i j,fun q hq => ?_,fun q hq => ?_,hm i j⟩
-    · rw [hA _ _ _ hq,contract_actual]; rfl
-    · rw [hB _ _ _ hq,contract_actual]; rfl
-  exact ⟨hh true true,hh true false,hh false true,hh false false⟩
-
-end Volley
-
-def scalarBlocks (p : Shape) {n} (M : Cross p n) (e : Place p) (i j : Bool) :=
-  channelOut p M j e * IP p n i
-
-theorem contract_val (p : Shape) {n} (M : Cross p n) (i j : Bool) (x : Profile p n) :
-    contract p M i j x = ∑ e,mpair
-      ((scalarBlocks p M (e,true) i j)ᵀ * scalarBlocks p M (e,false) i j) (x e) := by
-  change ∑ e : Comp p.g, _ = _
-  refine Finset.sum_congr rfl fun e _ => ?_
-  rw [mpair_liftM]
-  simp only [liftM_def,transpose_transpose,scalarBlocks,transpose_mul,Matrix.mul_assoc]
-
-theorem contract_scalars (A M : Cross p n) (h : scalarBlocks p A=scalarBlocks p M) (i j) :
-    contract p A i j=contract p M i j := by
-  refine LinearMap.ext fun v => ?_
-  rw [contract_val,contract_val,h]
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.KeyDirections
+
+namespace OAI
+
+/-! # Realization Conditions -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Matrix
+open scoped BigOperators
+variable {p : Shape} {n N : ℕ} {I : Type} [Fintype I]
+
+namespace Volley
+variable (v w : Volley p n I)
+
+def legal (t : Tagging p I) := ∀ i : I, allows (t i) (v.par i)
+def diagonalAt (i : I) := eta p n (mom p (v.sel i) (v.par i))
+def bounded (w' : I→Bool) := ∀ (i j : Bool), 1≤ (v.shoots w' i j).card ∧
+    (v.shoots w' i j).card ≤7
+
+/-- Conditions for one orientation of roles, §5 (scalar recipe). -/
+structure scalarRecipe (t : Tagging p I) (m : Mixer p n) (x : UnitType p n N) (S : Plan p n)
+    (M : Cross p n) : Prop where
+  summ (i j : Bool) : ∑ a ∈ v.shoots w.obj i j,v.diagonalAt a=1
+  coupled (j : Bool) : ((innerP p x true)+role p n) (v.sumAt t w.obj true j) =
+    ((innerP p x false)+role p n) (v.sumAt t w.obj false j)
+  gradient (i j : Bool) (y : Profile p n) : y∈effective S i →
+    grad m (v.sumAt t w.obj i j) y= contract p M i j y
+
+def roleMatch (t : Tagging p I) :=
+  ∀ i j, role p n (v.sumAt t w.obj i j)+ role p n (w.sumAt t v.obj j i)=1
+
+def attackGrad (t : Tagging p I) (m : Mixer p n) (y : UnitType p n N) :=
+  ∀ (a : I) (j : Bool),
+    grad m (v.sumAt t w.obj (v.obj a) j) (v.atomAt t a) =
+      if j=w.obj a then 0 else innerP p y (w.obj a) (w.atomAt t a)
+
+def realized (t : Tagging p I) (m : Mixer p n) (M : Cross p n) :=
+  ∀ i j, ∀ y ∈ Xspace p n, grad m (v.sumAt t w.obj i j) y=contract p M i j y
+
+theorem shoots_swap (i j) : v.shoots w.obj i j=w.shoots v.obj j i := by
+  ext; simp [shoots,and_comm]
+
+theorem sum_share {t : Tagging p I} {x y : UnitType p n N} (h : v.keys t x=w.keys t y)
+    (i j : Bool) : Uembed (onSide x i) (v.sumAt t w.obj i j)=
+      Uembed (onSide y j) (w.sumAt t v.obj j i) := by
+  classical
+  unfold sumAt
+  rw [map_sum,map_sum,← shoots_swap v w]
+  refine Finset.sum_congr rfl fun k hk => ?_
+  have hi := (Finset.mem_filter.mp hk).2
+  rw [← hi.1, ← hi.2]
+  exact v.atom_share _ _ _ _ h k
+
+theorem sum_mem {t : Tagging p I} (h : v.legal t) (f : I → Bool) (i j : Bool) :
+    v.sumAt t f i j∈Xspace p n :=
+  Submodule.sum_mem _ fun k _ => atom_mem _ (h k)
+
+theorem realized_conflicts {t : Tagging p I} (m : Mixer p n)
+    (x y : UnitType p n N) (hv : v.legal t) (hw : w.legal t)
+    (hL : ∀ i, frameLaw m (onSide x i)) (hR : ∀ i, frameLaw m (onSide y i))
+    (h : v.keys t x=w.keys t y) (hm : v.roleMatch w t)
+    (hA : v.realized w t m (actual p x y)) (hB : w.realized v t m (actual p y x)) :
+    (rawHoles m).conflict x y := by
+  have hh i j : hole m (onSide x i) (onSide y j) := by
+    refine ⟨hL i,hR j,v.sumAt t w.obj i j,w.sumAt t v.obj j i,
+      v.sum_mem hv .., w.sum_mem hw .., v.sum_share _ h i j,fun q hq => ?_,fun q hq => ?_,hm i j⟩
+    · rw [hA _ _ _ hq,contract_actual]; rfl
+    · rw [hB _ _ _ hq,contract_actual]; rfl
+  exact ⟨hh true true,hh true false,hh false true,hh false false⟩
+
+end Volley
+
+def scalarBlocks (p : Shape) {n} (M : Cross p n) (e : Place p) (i j : Bool) :=
+  channelOut p M j e * IP p n i
+
+theorem contract_val (p : Shape) {n} (M : Cross p n) (i j : Bool) (x : Profile p n) :
+    contract p M i j x = ∑ e,mpair
+      ((scalarBlocks p M (e,true) i j)ᵀ * scalarBlocks p M (e,false) i j) (x e) := by
+  change ∑ e : Comp p.g, _ = _
+  refine Finset.sum_congr rfl fun e _ => ?_
+  rw [mpair_liftM]
+  simp only [liftM_def,transpose_transpose,scalarBlocks,transpose_mul,Matrix.mul_assoc]
+
+theorem contract_scalars (A M : Cross p n) (h : scalarBlocks p A=scalarBlocks p M) (i j) :
+    contract p A i j=contract p M i j := by
+  refine LinearMap.ext fun v => ?_
+  rw [contract_val,contract_val,h]
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/RectangleComparisons.lean

@@ -1,146 +1,146 @@
-import OAI.Combinatorics.HadwigerCounterexample.SurrogateProductBounds
-
-namespace OAI
-
-/-! # Rectangle Comparisons -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Filter Finset Matrix Function
-open scoped BigOperators Topology
-variable {p:Shape} {n N r : ℕ}
-open Template
-namespace StatusAnalysis
-
-private theorem warm_bound {u v : ℝ} (h : |u|≤1) {r:ℝ}
-    (hv : |v|≤r) : |u*v|≤r := by
-  rw [abs_mul]; exact (mul_le_mul h hv (abs_nonneg _) zero_le_one).trans_eq (one_mul _)
-
-namespace Quill
-variable {q : Format} {d : Rates} {b : Bool}
-    (w : Quill p q d b) (t : Tagging p (Messenger q)) (z : Messenger q→F)
-    (m : Mixer p n)
-
-structure mirrorSpan (s:ℕ) (ε : ℝ) (Y:Silhouette p N r) (o:UnitType p n N) : Prop where
-  law : ∀ i,IsLaw (w.policies t z n i)
-  frame : ∀ i,frameLaw m (onSide o i)
-  close : ∀ i,(w.allure t z i).close Y (onSide o (parcel b i)) ε
-  ready : ∀ u:Messenger q → Wgt (Knobs p.g n),(∀ i x, |u i x|≤1) →
-    let v:=w.pen t; let x:=w.policies t z n
-    |avg (prodW x) (fun y=>ind (v.performs w.script m o y)*prodW u y)-v.kappa*∏ i:Messenger q,
-      avg (x i) (u i)|≤ ε
-  reference : ∀ f:∀ i:Messenger q,Wgt (AtomKey (p:=p) (t i) N),(∀ i x,|f i x|≤1) →
-     |avg (lawNu p N t z) (prodW f) - ∏ i:Messenger q,avg (lawOmega p N (t i) (z i)) (f i)| ≤ ε
-
-set_option maxHeartbeats 800000 in
-theorem paint_agree (Y:Silhouette p N r) (o: UnitType p n N) (s : Charts p n d)
-    (f:Paint (w.pen t) N) (hF : pigments z Y f)
-    (hg : 2≤p.g) (hj : 1≤p.j) (hc : |f.coeff|≤1) {u ℓ}
-    (he : w.mirrorSpan t z m ℓ u Y o) :
-    |w.prowl s t z m o f.cost-w.sheen t z o m s Y f.cost|≤(2+num (Messenger q))*u := by
-  classical
-  let A:= w.suede t z o m s f; let x:= w.policies t z n
-  let V:= w.pen t
-  let B:= w.insidePaint t z o m s Y f
-  let Q:= avg (prodW x) (fun y=>ind (V.performs w.script m o y)*prodW A y)
-  let E:=avg (lawNu p N t z) (prodW B)
-  have hb i y := paintFloor w t z o m s Y f i y (he.law _)
-  have ha := suedeFloor w t z o m s f
-  let h := he.law
-  let P i := avg (x i) (A i); let R i:= avg (lawOmega p N (t i) (z i)) (B i)
-  have hm : |Q-V.kappa*(∏ i,P i)|≤u := he.ready A ha
-  have hf : |E-∏ i,R i|≤u := he.reference B hb
-  have hP i : |P i|≤1 := by
-    exact (abs_avg_le (h i).nz).trans ((avg_mono (h i).nz (ha i)).trans_eq ((h i).avg_const _))
-  have hR i : |R i|≤1 := by
-    have hv : SubLaw (lawOmega p N (t i) (z i)) := unifOn_sub _
-    exact (abs_avg_le hv.nz).trans (hv.avg_le zero_le_one (hb i))
-  have hh : |(∏ i, P i)-(∏ i, R i)|≤num (Messenger q)*u :=
-    cottonError _ _ _ _ hP hR (fun i =>(abs_sub_comm ..).trans_le
-      (surrogate_close w t z o m s Y f hF _ (h _) (he.close _)))
-  have hK : |V.kappa|≤1 := by rw [abs_of_pos V.kappa_pos]; exact w.kappaTop t
-  rw [score_prowl w t z o m s f he.frame hg hj,score_sheen w t z o m,←mul_sub]
-  apply warm_bound hc
-  have hh' : |V.kappa*(∏ i,P i)-V.kappa*E|≤num (Messenger q)*u+u := by
-    rw [←mul_sub]; exact warm_bound hK ((abs_sub_le (∏ i,P i) (∏ i,R i) E).trans (add_le_add hh
-      ((abs_sub_comm ..).trans_le hf)))
-  exact ((abs_sub_le Q _ (V.kappa*E)).trans (add_le_add hm hh')).trans_eq (by ring)
-
-set_option maxHeartbeats 800000 in
-theorem paint_set (Y:Silhouette p N r) (o: UnitType p n N) (s : Charts p n d)
-    {r' : ℕ}
-    (f:Fin r' → Paint (w.pen t) N) (hF : ∀ i,pigments z Y (f i))
-    (hg : 2≤p.g) (hj : 1≤p.j) (hc : ∀ i,|(f i).coeff|≤1) {u ℓ}
-    (he : w.mirrorSpan t z m ℓ u Y o) :
-    |w.prowl s t z m o (mural (w.pen t) f)-w.sheen t z o m s Y (mural (w.pen t) f)|≤
-       r' * ((2+num (Messenger q))*u) := by
-  classical
-  let F i : Wgt (Keys (p:=p) t N) := (f i).cost
-  let R := show Wgt (Keys (p:=p) t N) from mural (w.pen t) f
-  have hf x : R x=∑ i:Fin r', F i x := rfl
-  change |w.prowl _ _ _ _ _ R-w.sheen _ _ _ _ _ _ R|≤_
-  have hh :
-      w.prowl s t z m o R=∑ i:Fin r',w.prowl s t z m o (F i) := by
-    let key : Inputs p n (Messenger q) → Keys (p:=p) t N := (w.pen t).resultKey o
-    change avg ((w.pen t).state z n) (fun x => ind (w.deposit t z m o s x) * R (key x)) =
-      ∑ i : Fin r', avg ((w.pen t).state z n)
-        (fun x => ind (w.deposit t z m o s x) * F i (key x))
-    simp_rw [hf, Finset.mul_sum,avg_sum]
-  have ht :
-      w.sheen t z o m s Y R=∑ i:Fin r',w.sheen t z o m s Y (F i) := by
-    unfold sheen; simp_rw [hf,Finset.mul_sum,avg_sum]
-  rw [hh,ht,←Finset.sum_sub_distrib]
-  apply (abs_sum_le_sum_abs ..).trans
-  exact (Finset.sum_le_sum fun i _=> paint_agree w t z m Y o s (f i) (hF i) hg hj (hc i)
-    he).trans_eq (by simp)
-
-structure witnessPaint (ε:ℝ) (W T : Wgt (Keys (p:=p) t N))
-    (o : UnitType p n N) : Prop where
-  shadow : ∀ f : (w.pen t).Localist N,(∀ i j, |f i j|≤1) →
-    |avg (lawNu p N t z) (fun x=>(W x-T x)*prodW f x)|≤ε
-  tested : ¬ exceeds (w.pen t) z (W-T) w.script m (w.policies t z n) ε o
-
-set_option maxHeartbeats 800000 in
-theorem bare_bridge (Y : Silhouette p N r) (o:UnitType p n N) (s:Charts p n d)
-    {r' : ℕ}
-    (f:Fin r' → Paint (w.pen t) N) (hF : ∀ i,pigments z Y (f i))
-    (hg : 2≤p.g) (hj : 1≤p.j) (hc : ∀ i,|(f i).coeff|≤1) {u ℓ ε}
-    (he : w.mirrorSpan t z m ℓ u Y o) (W : Wgt (Keys (p:=p) t N))
-    (hw : w.witnessPaint t z m ε W (mural (w.pen t) f) o) :
-    |w.prowl s t z m o W-w.sheen t z o m s Y W|≤ 2*ε +r'*((2+num (Messenger q))*u) := by
-  classical
-  let A:=w.pen t
-  let T:= show Wgt (Keys (p:=p) t N) from mural A f
-  let x:=w.prowl s t z m o; let y:= w.sheen t z o m s Y
-  have h1 : |x W-x T|≤ε := by
-    have hz : x W-x T=x (W-T) := by
-      let key : Inputs p n (Messenger q) → Keys (p:=p) t N := A.resultKey o
-      change avg (A.state z n) (fun x => ind (w.deposit t z m o s x) * W (key x)) -
-        avg (A.state z n) (fun x => ind (w.deposit t z m o s x) * T (key x)) =
-        avg (A.state z n) (fun x => ind (w.deposit t z m o s x) * (W-T) (key x))
-      rw [←avg_sub]
-      simp only [Pi.sub_apply,mul_sub]
-    rw [hz]
-    change |w.prowl _ _ _ _ _ _|≤_
-    rw [prowl_astonish]
-    exact le_of_not_gt (fun h=> hw.tested ⟨_, stencil_floor w t z o s m,h⟩)
-  have h2 : |y W-y T|≤ε := by
-    unfold y; rw [sheen_sun,sheen_sun,←mul_sub,←avg_sub]
-    let B:= w.seraph t z o m s Y
-    have hF (i j): |B i j|≤1 := by
-      have hh:= w.seraphFloor t z o m s Y i (he.law i) j; rw [abs_of_nonneg (show 0≤B i j
-        from hh.1)]; exact hh.2
-    simp_rw [←sub_mul]; exact warm_bound (show |A.kappa|≤1 from (abs_of_pos A.kappa_pos).trans_le
-      (w.kappaTop t)) (hw.shadow B hF)
-  have h3 := paint_set w t z m Y o s f hF hg hj hc he
-  exact (abs_sub_le (x W) (x T) (y W)).trans ((add_le_add h1
-    ((abs_sub_le (x T) (y T) (y W)).trans (add_le_add h3 ((abs_sub_comm ..).trans_le h2)))).trans_eq
-      (by ring))
-
-end Quill
-end StatusAnalysis
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.SurrogateProductBounds
+
+namespace OAI
+
+/-! # Rectangle Comparisons -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Filter Finset Matrix Function
+open scoped BigOperators Topology
+variable {p:Shape} {n N r : ℕ}
+open Template
+namespace StatusAnalysis
+
+private theorem warm_bound {u v : ℝ} (h : |u|≤1) {r:ℝ}
+    (hv : |v|≤r) : |u*v|≤r := by
+  rw [abs_mul]; exact (mul_le_mul h hv (abs_nonneg _) zero_le_one).trans_eq (one_mul _)
+
+namespace Quill
+variable {q : Format} {d : Rates} {b : Bool}
+    (w : Quill p q d b) (t : Tagging p (Messenger q)) (z : Messenger q→F)
+    (m : Mixer p n)
+
+structure mirrorSpan (s:ℕ) (ε : ℝ) (Y:Silhouette p N r) (o:UnitType p n N) : Prop where
+  law : ∀ i,IsLaw (w.policies t z n i)
+  frame : ∀ i,frameLaw m (onSide o i)
+  close : ∀ i,(w.allure t z i).close Y (onSide o (parcel b i)) ε
+  ready : ∀ u:Messenger q → Wgt (Knobs p.g n),(∀ i x, |u i x|≤1) →
+    let v:=w.pen t; let x:=w.policies t z n
+    |avg (prodW x) (fun y=>ind (v.performs w.script m o y)*prodW u y)-v.kappa*∏ i:Messenger q,
+      avg (x i) (u i)|≤ ε
+  reference : ∀ f:∀ i:Messenger q,Wgt (AtomKey (p:=p) (t i) N),(∀ i x,|f i x|≤1) →
+     |avg (lawNu p N t z) (prodW f) - ∏ i:Messenger q,avg (lawOmega p N (t i) (z i)) (f i)| ≤ ε
+
+set_option maxHeartbeats 800000 in
+theorem paint_agree (Y:Silhouette p N r) (o: UnitType p n N) (s : Charts p n d)
+    (f:Paint (w.pen t) N) (hF : pigments z Y f)
+    (hg : 2≤p.g) (hj : 1≤p.j) (hc : |f.coeff|≤1) {u ℓ}
+    (he : w.mirrorSpan t z m ℓ u Y o) :
+    |w.prowl s t z m o f.cost-w.sheen t z o m s Y f.cost|≤(2+num (Messenger q))*u := by
+  classical
+  let A:= w.suede t z o m s f; let x:= w.policies t z n
+  let V:= w.pen t
+  let B:= w.insidePaint t z o m s Y f
+  let Q:= avg (prodW x) (fun y=>ind (V.performs w.script m o y)*prodW A y)
+  let E:=avg (lawNu p N t z) (prodW B)
+  have hb i y := paintFloor w t z o m s Y f i y (he.law _)
+  have ha := suedeFloor w t z o m s f
+  let h := he.law
+  let P i := avg (x i) (A i); let R i:= avg (lawOmega p N (t i) (z i)) (B i)
+  have hm : |Q-V.kappa*(∏ i,P i)|≤u := he.ready A ha
+  have hf : |E-∏ i,R i|≤u := he.reference B hb
+  have hP i : |P i|≤1 := by
+    exact (abs_avg_le (h i).nz).trans ((avg_mono (h i).nz (ha i)).trans_eq ((h i).avg_const _))
+  have hR i : |R i|≤1 := by
+    have hv : SubLaw (lawOmega p N (t i) (z i)) := unifOn_sub _
+    exact (abs_avg_le hv.nz).trans (hv.avg_le zero_le_one (hb i))
+  have hh : |(∏ i, P i)-(∏ i, R i)|≤num (Messenger q)*u :=
+    cottonError _ _ _ _ hP hR (fun i =>(abs_sub_comm ..).trans_le
+      (surrogate_close w t z o m s Y f hF _ (h _) (he.close _)))
+  have hK : |V.kappa|≤1 := by rw [abs_of_pos V.kappa_pos]; exact w.kappaTop t
+  rw [score_prowl w t z o m s f he.frame hg hj,score_sheen w t z o m,←mul_sub]
+  apply warm_bound hc
+  have hh' : |V.kappa*(∏ i,P i)-V.kappa*E|≤num (Messenger q)*u+u := by
+    rw [←mul_sub]; exact warm_bound hK ((abs_sub_le (∏ i,P i) (∏ i,R i) E).trans (add_le_add hh
+      ((abs_sub_comm ..).trans_le hf)))
+  exact ((abs_sub_le Q _ (V.kappa*E)).trans (add_le_add hm hh')).trans_eq (by ring)
+
+set_option maxHeartbeats 800000 in
+theorem paint_set (Y:Silhouette p N r) (o: UnitType p n N) (s : Charts p n d)
+    {r' : ℕ}
+    (f:Fin r' → Paint (w.pen t) N) (hF : ∀ i,pigments z Y (f i))
+    (hg : 2≤p.g) (hj : 1≤p.j) (hc : ∀ i,|(f i).coeff|≤1) {u ℓ}
+    (he : w.mirrorSpan t z m ℓ u Y o) :
+    |w.prowl s t z m o (mural (w.pen t) f)-w.sheen t z o m s Y (mural (w.pen t) f)|≤
+       r' * ((2+num (Messenger q))*u) := by
+  classical
+  let F i : Wgt (Keys (p:=p) t N) := (f i).cost
+  let R := show Wgt (Keys (p:=p) t N) from mural (w.pen t) f
+  have hf x : R x=∑ i:Fin r', F i x := rfl
+  change |w.prowl _ _ _ _ _ R-w.sheen _ _ _ _ _ _ R|≤_
+  have hh :
+      w.prowl s t z m o R=∑ i:Fin r',w.prowl s t z m o (F i) := by
+    let key : Inputs p n (Messenger q) → Keys (p:=p) t N := (w.pen t).resultKey o
+    change avg ((w.pen t).state z n) (fun x => ind (w.deposit t z m o s x) * R (key x)) =
+      ∑ i : Fin r', avg ((w.pen t).state z n)
+        (fun x => ind (w.deposit t z m o s x) * F i (key x))
+    simp_rw [hf, Finset.mul_sum,avg_sum]
+  have ht :
+      w.sheen t z o m s Y R=∑ i:Fin r',w.sheen t z o m s Y (F i) := by
+    unfold sheen; simp_rw [hf,Finset.mul_sum,avg_sum]
+  rw [hh,ht,←Finset.sum_sub_distrib]
+  apply (abs_sum_le_sum_abs ..).trans
+  exact (Finset.sum_le_sum fun i _=> paint_agree w t z m Y o s (f i) (hF i) hg hj (hc i)
+    he).trans_eq (by simp)
+
+structure witnessPaint (ε:ℝ) (W T : Wgt (Keys (p:=p) t N))
+    (o : UnitType p n N) : Prop where
+  shadow : ∀ f : (w.pen t).Localist N,(∀ i j, |f i j|≤1) →
+    |avg (lawNu p N t z) (fun x=>(W x-T x)*prodW f x)|≤ε
+  tested : ¬ exceeds (w.pen t) z (W-T) w.script m (w.policies t z n) ε o
+
+set_option maxHeartbeats 800000 in
+theorem bare_bridge (Y : Silhouette p N r) (o:UnitType p n N) (s:Charts p n d)
+    {r' : ℕ}
+    (f:Fin r' → Paint (w.pen t) N) (hF : ∀ i,pigments z Y (f i))
+    (hg : 2≤p.g) (hj : 1≤p.j) (hc : ∀ i,|(f i).coeff|≤1) {u ℓ ε}
+    (he : w.mirrorSpan t z m ℓ u Y o) (W : Wgt (Keys (p:=p) t N))
+    (hw : w.witnessPaint t z m ε W (mural (w.pen t) f) o) :
+    |w.prowl s t z m o W-w.sheen t z o m s Y W|≤ 2*ε +r'*((2+num (Messenger q))*u) := by
+  classical
+  let A:=w.pen t
+  let T:= show Wgt (Keys (p:=p) t N) from mural A f
+  let x:=w.prowl s t z m o; let y:= w.sheen t z o m s Y
+  have h1 : |x W-x T|≤ε := by
+    have hz : x W-x T=x (W-T) := by
+      let key : Inputs p n (Messenger q) → Keys (p:=p) t N := A.resultKey o
+      change avg (A.state z n) (fun x => ind (w.deposit t z m o s x) * W (key x)) -
+        avg (A.state z n) (fun x => ind (w.deposit t z m o s x) * T (key x)) =
+        avg (A.state z n) (fun x => ind (w.deposit t z m o s x) * (W-T) (key x))
+      rw [←avg_sub]
+      simp only [Pi.sub_apply,mul_sub]
+    rw [hz]
+    change |w.prowl _ _ _ _ _ _|≤_
+    rw [prowl_astonish]
+    exact le_of_not_gt (fun h=> hw.tested ⟨_, stencil_floor w t z o s m,h⟩)
+  have h2 : |y W-y T|≤ε := by
+    unfold y; rw [sheen_sun,sheen_sun,←mul_sub,←avg_sub]
+    let B:= w.seraph t z o m s Y
+    have hF (i j): |B i j|≤1 := by
+      have hh:= w.seraphFloor t z o m s Y i (he.law i) j; rw [abs_of_nonneg (show 0≤B i j
+        from hh.1)]; exact hh.2
+    simp_rw [←sub_mul]; exact warm_bound (show |A.kappa|≤1 from (abs_of_pos A.kappa_pos).trans_le
+      (w.kappaTop t)) (hw.shadow B hF)
+  have h3 := paint_set w t z m Y o s f hF hg hj hc he
+  exact (abs_sub_le (x W) (x T) (y W)).trans ((add_le_add h1
+    ((abs_sub_le (x T) (y T) (y W)).trans (add_le_add h3 ((abs_sub_comm ..).trans_le h2)))).trans_eq
+      (by ring))
+
+end Quill
+end StatusAnalysis
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/RectangleRegularity.lean

@@ -1,115 +1,115 @@
-import OAI.Combinatorics.HadwigerCounterexample.ConditionalProjection
-
-namespace OAI
-
-/-! # Rectangle Regularity -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Finset Real Function
-open scoped BigOperators
-variable {A B C K : Type} [Fintype A] [Fintype B] [Fintype C]
-
-def thinCut (μ f : Wgt A) (x : A→B) (y : A→C) (ε : ℝ) :=
-  ∀ u : Wgt B,(∀ i,|u i|≤1) → ∀ v : Wgt C,(∀ i,|v i|≤1) →
-    |avg μ (fun i=> f i*(u (x i)*v (y i)))|≤ ε
-def doubleBook {L R : Type} (x : A→B) (y : A→C) (a : B→L) (b : C→R) :=
-  fun i => (a (x i),b (y i))
-def swab (x : Bool) : ℝ := if x then 1 else -1
-theorem swab_abs (x) : |swab x|=1 := by cases x <;> simp [swab]
-
-private theorem sign_mass (w : Wgt A) (f : A→B) (u : Wgt B) (h : ∀ i,|u i|≤1) :
-    ∃ y : B→Bool,|avg w (u ∘ f)|≤|avg w (swab ∘ y ∘ f)| := by
-  classical
-  let p := mapW w f
-  let y (i) := decide (0≤p i)
-  have he i :
-      p i*swab (y i)=|p i| := by
-    by_cases hh : 0≤p i <;> simp [swab,y,hh,abs_of_nonneg,abs_of_neg,lt_of_not_ge]
-  have hu :
-      |avg p u| ≤ ∑ i,|p i| := by
-    unfold avg; refine (Finset.abs_sum_le_sum_abs ..).trans ?_
-    refine Finset.sum_le_sum fun i _ => ?_
-    rw [abs_mul]
-    exact (mul_le_mul_of_nonneg_left (h i) (abs_nonneg _)).trans_eq (mul_one _)
-  have hz : avg p (swab ∘ y) = ∑ i, |p i| := Finset.sum_congr rfl fun i _=> he i
-  refine ⟨y,?_⟩
-  rw [show avg w (u∘f)=avg p u from (mapW_avg w f u).symm,show avg w (swab∘y∘f)=
-    avg p (swab∘y) from (mapW_avg w f (swab ∘ y)).symm]
-  exact hu.trans (hz.symm.le.trans (le_abs_self _))
-
-theorem cut_witness (μ f : Wgt A) {x : A→B} {y : A→C} {ε : ℝ} (h : ¬ thinCut μ f x y ε) :
-    ∃ (i : B→Bool) (j : C→Bool), ε < |avg μ (fun z=>f z*(swab (i (x z))*swab (j (y z))))| := by
-  classical
-  unfold thinCut at h
-  push Not at h
-  obtain ⟨u,hu,v,hv,h⟩ := h
-  let Q (u : Wgt B) (v : Wgt C) := avg μ (fun z=>f z*(u (x z)*v (y z)))
-  let U z := μ z*f z*v (y z)
-  obtain ⟨i,hi⟩ := sign_mass U x u hu
-  have hx (u) : Q u v=avg U (u∘x) := Finset.sum_congr rfl (fun z _=>by unfold U Function.comp; ring)
-  let V z := μ z*f z*swab (i (x z))
-  obtain ⟨j,hj⟩ := sign_mass V y v hv
-  have hy (v) : Q (swab ∘ i) v=avg V (v∘y) := Finset.sum_congr rfl (fun z _=>by
-    unfold V Function.comp; ring)
-  rw [←hx u,show avg U (swab ∘ i ∘ x)=Q (swab ∘ i) v from (hx (swab ∘ i)).symm] at hi
-  rw [←hy v,show avg V (swab ∘ j ∘ y)=Q (swab ∘ i) (swab∘j) from (hy (swab ∘ j)).symm] at hj
-  exact ⟨i,j, lt_of_lt_of_le h (hi.trans hj)⟩
-
-def weakRank (μ f : Wgt A) (x : A→B) (y : A→C) (δ : ℝ) (R : ℕ) :=
-  ∃ l : ℕ,l≤R ∧ ∃ (a:B→Fin l) (b:C→ Fin l),
-    thinCut μ (fun i=> f i-banner μ (doubleBook x y a b) f i) x y δ
-
-set_option maxHeartbeats 800000 in
-theorem plenty_cuts (δ M : ℝ) (hδ : 0<δ) (hM : 0≤M) :
-    ∃ r:ℕ,∀ (A B C : Type) [Fintype A] [Fintype B] [Fintype C]
-      (μ f : Wgt A) (x : A→B) (y : A→C),SubLaw μ → (∀ i,|f i| ≤ M) →
-        weakRank μ f x y δ r := by
-  classical
-  obtain ⟨l,hl⟩ := exists_nat_gt (M^2 / δ^2)
-  refine ⟨2^l,fun A B C _ _ _ μ f x y hw hf => ?_⟩
-  by_contra h
-  have hh (i : ℕ) (hi : i≤l) :
-      ∃ (a:B→Fin (2^i)) (b:C→Fin (2^i)), i*δ^2 ≤ ode μ (banner μ (doubleBook x y a b) f) := by
-    induction i with
-    | zero => exact ⟨fun _=>0,fun _=>0, by simpa using ode_nonneg hw.nz _⟩
-    | succ i ih =>
-      obtain ⟨a,b,he⟩ := ih (by omega)
-      let T := doubleBook x y a b
-      let d := fun z => f z-banner μ T f z
-      obtain ⟨u,v,e⟩ := cut_witness μ d (x:=x) (y:=y) (ε:=δ) (fun p =>
-        h ⟨_,Nat.pow_le_pow_right (by decide) (by omega),a,b,p⟩)
-      let r := 2^i
-      let E : Fin r × Bool ≃ Fin (2^(i+1)) := Fintype.equivFinOfCardEq (by simp [r,pow_succ])
-      let a' z := E (a z,u z); let b' z := E (b z,v z)
-      let S := doubleBook x y a' b'
-      let U (z j : Fin (2^(i+1))) := ((E.symm z).1,(E.symm j).1)
-      let V (z j : Fin (2^(i+1))) := swab (E.symm z).2*swab (E.symm j).2
-      have hz : uncurry U ∘ S=T := by
-        funext i; simp only [doubleBook,a',b',Function.comp_apply,U,S,uncurry_apply_pair,
-          Equiv.symm_apply_apply]; rfl
-      have hH (i) : uncurry V (S i)=swab (u (x i))*swab (v (y i)) := by
-        simp only [S,doubleBook,a',b',V,uncurry_apply_pair,Equiv.symm_apply_apply]
-      have hh (i) : |uncurry V (S i)| ≤ 1 := by rw [hH,abs_mul,swab_abs,swab_abs,mul_one]
-      have hq := archive_gain hw f S (uncurry U) (uncurry V) hh
-      rw [hz] at hq
-      have ht : dip μ d (uncurry V ∘ S)=
-          avg μ (fun z => d z*(swab (u (x z))*swab (v (y z)))) :=
-        avg_congr (fun i _=> congrArg _ (hH i))
-      change (dip μ d _)^2≤_ at hq
-      rw [←ht] at e
-      refine ⟨a',b',?_⟩
-      change ↑(i+1)*δ^2≤ode μ (banner μ S f)
-      change ↑i*δ^2≤ode μ (banner μ T f) at he
-      push_cast
-      nlinarith only [he,hq,e,sq_abs (dip μ d (uncurry V ∘ S)),hδ]
-  obtain ⟨a,b,he⟩ := hh l le_rfl
-  let F := doubleBook x y a b
-  have hb := cashbook_bound μ hw.nz F f M hM hf
-  have ht := he.trans (ode_upper hw _ M (fun i : A=> hb (F i)))
-  exact not_lt_of_ge ht ((div_lt_iff₀ (by positivity)).mp hl)
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.ConditionalProjection
+
+namespace OAI
+
+/-! # Rectangle Regularity -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Finset Real Function
+open scoped BigOperators
+variable {A B C K : Type} [Fintype A] [Fintype B] [Fintype C]
+
+def thinCut (μ f : Wgt A) (x : A→B) (y : A→C) (ε : ℝ) :=
+  ∀ u : Wgt B,(∀ i,|u i|≤1) → ∀ v : Wgt C,(∀ i,|v i|≤1) →
+    |avg μ (fun i=> f i*(u (x i)*v (y i)))|≤ ε
+def doubleBook {L R : Type} (x : A→B) (y : A→C) (a : B→L) (b : C→R) :=
+  fun i => (a (x i),b (y i))
+def swab (x : Bool) : ℝ := if x then 1 else -1
+theorem swab_abs (x) : |swab x|=1 := by cases x <;> simp [swab]
+
+private theorem sign_mass (w : Wgt A) (f : A→B) (u : Wgt B) (h : ∀ i,|u i|≤1) :
+    ∃ y : B→Bool,|avg w (u ∘ f)|≤|avg w (swab ∘ y ∘ f)| := by
+  classical
+  let p := mapW w f
+  let y (i) := decide (0≤p i)
+  have he i :
+      p i*swab (y i)=|p i| := by
+    by_cases hh : 0≤p i <;> simp [swab,y,hh,abs_of_nonneg,abs_of_neg,lt_of_not_ge]
+  have hu :
+      |avg p u| ≤ ∑ i,|p i| := by
+    unfold avg; refine (Finset.abs_sum_le_sum_abs ..).trans ?_
+    refine Finset.sum_le_sum fun i _ => ?_
+    rw [abs_mul]
+    exact (mul_le_mul_of_nonneg_left (h i) (abs_nonneg _)).trans_eq (mul_one _)
+  have hz : avg p (swab ∘ y) = ∑ i, |p i| := Finset.sum_congr rfl fun i _=> he i
+  refine ⟨y,?_⟩
+  rw [show avg w (u∘f)=avg p u from (mapW_avg w f u).symm,show avg w (swab∘y∘f)=
+    avg p (swab∘y) from (mapW_avg w f (swab ∘ y)).symm]
+  exact hu.trans (hz.symm.le.trans (le_abs_self _))
+
+theorem cut_witness (μ f : Wgt A) {x : A→B} {y : A→C} {ε : ℝ} (h : ¬ thinCut μ f x y ε) :
+    ∃ (i : B→Bool) (j : C→Bool), ε < |avg μ (fun z=>f z*(swab (i (x z))*swab (j (y z))))| := by
+  classical
+  unfold thinCut at h
+  push Not at h
+  obtain ⟨u,hu,v,hv,h⟩ := h
+  let Q (u : Wgt B) (v : Wgt C) := avg μ (fun z=>f z*(u (x z)*v (y z)))
+  let U z := μ z*f z*v (y z)
+  obtain ⟨i,hi⟩ := sign_mass U x u hu
+  have hx (u) : Q u v=avg U (u∘x) := Finset.sum_congr rfl (fun z _=>by unfold U Function.comp; ring)
+  let V z := μ z*f z*swab (i (x z))
+  obtain ⟨j,hj⟩ := sign_mass V y v hv
+  have hy (v) : Q (swab ∘ i) v=avg V (v∘y) := Finset.sum_congr rfl (fun z _=>by
+    unfold V Function.comp; ring)
+  rw [←hx u,show avg U (swab ∘ i ∘ x)=Q (swab ∘ i) v from (hx (swab ∘ i)).symm] at hi
+  rw [←hy v,show avg V (swab ∘ j ∘ y)=Q (swab ∘ i) (swab∘j) from (hy (swab ∘ j)).symm] at hj
+  exact ⟨i,j, lt_of_lt_of_le h (hi.trans hj)⟩
+
+def weakRank (μ f : Wgt A) (x : A→B) (y : A→C) (δ : ℝ) (R : ℕ) :=
+  ∃ l : ℕ,l≤R ∧ ∃ (a:B→Fin l) (b:C→ Fin l),
+    thinCut μ (fun i=> f i-banner μ (doubleBook x y a b) f i) x y δ
+
+set_option maxHeartbeats 800000 in
+theorem plenty_cuts (δ M : ℝ) (hδ : 0<δ) (hM : 0≤M) :
+    ∃ r:ℕ,∀ (A B C : Type) [Fintype A] [Fintype B] [Fintype C]
+      (μ f : Wgt A) (x : A→B) (y : A→C),SubLaw μ → (∀ i,|f i| ≤ M) →
+        weakRank μ f x y δ r := by
+  classical
+  obtain ⟨l,hl⟩ := exists_nat_gt (M^2 / δ^2)
+  refine ⟨2^l,fun A B C _ _ _ μ f x y hw hf => ?_⟩
+  by_contra h
+  have hh (i : ℕ) (hi : i≤l) :
+      ∃ (a:B→Fin (2^i)) (b:C→Fin (2^i)), i*δ^2 ≤ ode μ (banner μ (doubleBook x y a b) f) := by
+    induction i with
+    | zero => exact ⟨fun _=>0,fun _=>0, by simpa using ode_nonneg hw.nz _⟩
+    | succ i ih =>
+      obtain ⟨a,b,he⟩ := ih (by omega)
+      let T := doubleBook x y a b
+      let d := fun z => f z-banner μ T f z
+      obtain ⟨u,v,e⟩ := cut_witness μ d (x:=x) (y:=y) (ε:=δ) (fun p =>
+        h ⟨_,Nat.pow_le_pow_right (by decide) (by omega),a,b,p⟩)
+      let r := 2^i
+      let E : Fin r × Bool ≃ Fin (2^(i+1)) := Fintype.equivFinOfCardEq (by simp [r,pow_succ])
+      let a' z := E (a z,u z); let b' z := E (b z,v z)
+      let S := doubleBook x y a' b'
+      let U (z j : Fin (2^(i+1))) := ((E.symm z).1,(E.symm j).1)
+      let V (z j : Fin (2^(i+1))) := swab (E.symm z).2*swab (E.symm j).2
+      have hz : uncurry U ∘ S=T := by
+        funext i; simp only [doubleBook,a',b',Function.comp_apply,U,S,uncurry_apply_pair,
+          Equiv.symm_apply_apply]; rfl
+      have hH (i) : uncurry V (S i)=swab (u (x i))*swab (v (y i)) := by
+        simp only [S,doubleBook,a',b',V,uncurry_apply_pair,Equiv.symm_apply_apply]
+      have hh (i) : |uncurry V (S i)| ≤ 1 := by rw [hH,abs_mul,swab_abs,swab_abs,mul_one]
+      have hq := archive_gain hw f S (uncurry U) (uncurry V) hh
+      rw [hz] at hq
+      have ht : dip μ d (uncurry V ∘ S)=
+          avg μ (fun z => d z*(swab (u (x z))*swab (v (y z)))) :=
+        avg_congr (fun i _=> congrArg _ (hH i))
+      change (dip μ d _)^2≤_ at hq
+      rw [←ht] at e
+      refine ⟨a',b',?_⟩
+      change ↑(i+1)*δ^2≤ode μ (banner μ S f)
+      change ↑i*δ^2≤ode μ (banner μ T f) at he
+      push_cast
+      nlinarith only [he,hq,e,sq_abs (dip μ d (uncurry V ∘ S)),hδ]
+  obtain ⟨a,b,he⟩ := hh l le_rfl
+  let F := doubleBook x y a b
+  have hb := cashbook_bound μ hw.nz F f M hM hf
+  have ht := he.trans (ode_upper hw _ M (fun i : A=> hb (F i)))
+  exact not_lt_of_ge ht ((div_lt_iff₀ (by positivity)).mp hl)
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/RecursiveComparisonErrors.lean

@@ -1,93 +1,93 @@
-import OAI.Combinatorics.HadwigerCounterexample.HeadPartitionComparison
-
-namespace OAI
-
-/-! # Recursive Comparison Errors -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Finset Function Filter Matrix
-open scoped BigOperators
-variable {p : Shape} {I : Type} [Fintype I] [DecidableEq I] {n N : ℕ}
-namespace Template
-variable (v : Template p I)
-
-theorem board_add (v : Template p I) (q : I→F) (U V : Wgt (Keys (p:=p) v.t N)) f :
-    board v q (U+V) f=board v q U f+board v q V f := by
-  unfold board curtain; simp only [Pi.add_apply,mul_add,add_mul,avg_add]
-
-theorem shadow_add (v : Template p I) (q : I→F) (U V : Wgt (Keys (p:=p) v.t N))
-    (r s : ℝ) (h : shadowed v q U r) (h' : shadowed v q V s) :
-    shadowed v q (U+V) (r+s) := fun f hf => by
-  rw [board_add]
-  exact (abs_add_le _ _).trans (add_le_add (h f hf) (h' f hf))
-
-theorem scene_join (v : Template p I) (q : I→ F) (U V : Wgt (Keys (p:=p) v.t N))
-    (s : Script p I) (m : Mixer p n) (w : I→Wgt (Knobs p.g n))
-    (x y : ℝ) (o : UnitType p n N)
-    (h : exceeds v q (U+V) s m w (x+y) o) :
-    exceeds v q U s m w x o ∨ exceeds v q V s m w y o := by
-  classical
-  obtain ⟨f,hf,h'⟩ := h
-  have he :
-      astonish v q (U+V) s m w f o=astonish v q U s m w f o+astonish v q V s m w f o := by
-    simp only [astonish_val,Pi.add_apply,mul_add,add_mul,avg_add]
-  change x+y < |astonish v q (U+V) s m w f o| at h'
-  rw [he] at h'
-  by_contra! hh
-  have ht : |astonish v q U s m w f o|≤x := le_of_not_gt (fun h=>hh.1 ⟨f,hf,h⟩)
-  have hv : |astonish v q V s m w f o|≤y := le_of_not_gt (fun h=>hh.2 ⟨f,hf,h⟩)
-  exact not_lt_of_ge ((abs_add_le _ _).trans (add_le_add ht hv)) h'
-
-def drained (m : Mixer p n) (C : ℝ) (w : Wgt (UnitType p n N)) :=
-    let μ := raw m N; let H:=bp ((1/32:ℝ)*n)
-    IsLaw w ∧ (∀ x,mapW w Prod.fst x ≤ H*μ x) ∧ (∀ x,mapW w Prod.snd x≤H*μ x) ∧
-      ∀ x,w x ≤ bp (C*N)*pairW μ μ x
-
-def engaged (v : Template p I) (q : I→F) (U : Wgt (Keys (p:=p) v.t N))
-    (n : ℕ) (C e ε : ℝ) :=
-  ∀ (m : Mixer p n),2*num (Full p n)<N →
-    ∀ (w : Wgt (UnitType p n N)),drained m C w →
-    ∀ (s : Script p I) (x : I→Wgt (Knobs p.g n)),(∀ i,IsLaw (x i)) →
-      (∀ i,mapW (x i) (freePart p)=unif) → pr w (exceeds v q U s m x ε) ≤ e
-
-set_option maxHeartbeats 800000 in
-theorem gild_play (v : Template p I) (j : I) (q : I→F) (n N r : ℕ)
-    (a : AtomKey (p:=p) (v.t j) N→Fin r) (B B' : Fin r→ Wgt (Keys (p:=p) (v.beyond j).t N))
-    (U : Wgt (Keys (p:=p) v.t N)) (C ε x y : ℝ)
-    (hs : shadowed v q (U-patched v j a B) ε)
-    (h : engaged v q (U-patched v j a B) n C x ε)
-    (hg : ∀ i,shadowed (v.beyond j) (v.boundTail j q) (B i-B' i) ε)
-    (hh : ∀ i,engaged (v.beyond j) (v.boundTail j q) (B i-B' i) n C y ε) :
-    let d:=U-patched v j a B'
-    shadowed v q d (ε+ε) ∧ engaged v q d n C (x+r*y) (ε+ε) := by
-  classical
-  intro d
-  let f:=U-patched v j a B
-  let V z := B z - B' z
-  let g:=patched v j a V
-  have hd : d=f+g := by
-    unfold d f g V; ext i; unfold patched; simp only [Pi.add_apply,Pi.sub_apply]
-    ring
-  rw [hd]
-  refine ⟨shadow_add v q f g ε ε hs (patched_board v j q a V ε hg),?_⟩
-  intro m hN w hw s u hu hz
-  let W (i) := exceeds (v.beyond j) (v.boundTail j q) (V i) (scriptTail s j) m
-    (fun i=>u i.val) ε
-  have he (o) (hf : exceeds v q g s m u ε o) : ∃ i,W i o := by
-    by_contra! hx
-    exact patched_exceed v j q a V ε u hu s m o hx hf
-  have hn := hw.1
-  have hi :
-      pr w (fun x => ∃ i:Fin r,W i x) ≤ (r:ℝ)*y := by
-    refine (pr_exists_le hn.nz W).trans ((Finset.sum_le_sum
-      (g:=fun _=>y) (fun i _=>?_)).trans_eq (by simp))
-    exact hh i m hN w hw (scriptTail s j) _ (fun i =>hu i.val) (fun i =>hz i.val)
-  apply (le_trans (pr_mono hn.nz (fun i => scene_join v q f g s m u _ _ i)) (pr_or_le hn.nz)).trans
-  exact add_le_add (h m hN w hw s u hu hz) ((pr_mono hn.nz he).trans hi)
-end Template
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.HeadPartitionComparison
+
+namespace OAI
+
+/-! # Recursive Comparison Errors -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Finset Function Filter Matrix
+open scoped BigOperators
+variable {p : Shape} {I : Type} [Fintype I] [DecidableEq I] {n N : ℕ}
+namespace Template
+variable (v : Template p I)
+
+theorem board_add (v : Template p I) (q : I→F) (U V : Wgt (Keys (p:=p) v.t N)) f :
+    board v q (U+V) f=board v q U f+board v q V f := by
+  unfold board curtain; simp only [Pi.add_apply,mul_add,add_mul,avg_add]
+
+theorem shadow_add (v : Template p I) (q : I→F) (U V : Wgt (Keys (p:=p) v.t N))
+    (r s : ℝ) (h : shadowed v q U r) (h' : shadowed v q V s) :
+    shadowed v q (U+V) (r+s) := fun f hf => by
+  rw [board_add]
+  exact (abs_add_le _ _).trans (add_le_add (h f hf) (h' f hf))
+
+theorem scene_join (v : Template p I) (q : I→ F) (U V : Wgt (Keys (p:=p) v.t N))
+    (s : Script p I) (m : Mixer p n) (w : I→Wgt (Knobs p.g n))
+    (x y : ℝ) (o : UnitType p n N)
+    (h : exceeds v q (U+V) s m w (x+y) o) :
+    exceeds v q U s m w x o ∨ exceeds v q V s m w y o := by
+  classical
+  obtain ⟨f,hf,h'⟩ := h
+  have he :
+      astonish v q (U+V) s m w f o=astonish v q U s m w f o+astonish v q V s m w f o := by
+    simp only [astonish_val,Pi.add_apply,mul_add,add_mul,avg_add]
+  change x+y < |astonish v q (U+V) s m w f o| at h'
+  rw [he] at h'
+  by_contra! hh
+  have ht : |astonish v q U s m w f o|≤x := le_of_not_gt (fun h=>hh.1 ⟨f,hf,h⟩)
+  have hv : |astonish v q V s m w f o|≤y := le_of_not_gt (fun h=>hh.2 ⟨f,hf,h⟩)
+  exact not_lt_of_ge ((abs_add_le _ _).trans (add_le_add ht hv)) h'
+
+def drained (m : Mixer p n) (C : ℝ) (w : Wgt (UnitType p n N)) :=
+    let μ := raw m N; let H:=bp ((1/32:ℝ)*n)
+    IsLaw w ∧ (∀ x,mapW w Prod.fst x ≤ H*μ x) ∧ (∀ x,mapW w Prod.snd x≤H*μ x) ∧
+      ∀ x,w x ≤ bp (C*N)*pairW μ μ x
+
+def engaged (v : Template p I) (q : I→F) (U : Wgt (Keys (p:=p) v.t N))
+    (n : ℕ) (C e ε : ℝ) :=
+  ∀ (m : Mixer p n),2*num (Full p n)<N →
+    ∀ (w : Wgt (UnitType p n N)),drained m C w →
+    ∀ (s : Script p I) (x : I→Wgt (Knobs p.g n)),(∀ i,IsLaw (x i)) →
+      (∀ i,mapW (x i) (freePart p)=unif) → pr w (exceeds v q U s m x ε) ≤ e
+
+set_option maxHeartbeats 800000 in
+theorem gild_play (v : Template p I) (j : I) (q : I→F) (n N r : ℕ)
+    (a : AtomKey (p:=p) (v.t j) N→Fin r) (B B' : Fin r→ Wgt (Keys (p:=p) (v.beyond j).t N))
+    (U : Wgt (Keys (p:=p) v.t N)) (C ε x y : ℝ)
+    (hs : shadowed v q (U-patched v j a B) ε)
+    (h : engaged v q (U-patched v j a B) n C x ε)
+    (hg : ∀ i,shadowed (v.beyond j) (v.boundTail j q) (B i-B' i) ε)
+    (hh : ∀ i,engaged (v.beyond j) (v.boundTail j q) (B i-B' i) n C y ε) :
+    let d:=U-patched v j a B'
+    shadowed v q d (ε+ε) ∧ engaged v q d n C (x+r*y) (ε+ε) := by
+  classical
+  intro d
+  let f:=U-patched v j a B
+  let V z := B z - B' z
+  let g:=patched v j a V
+  have hd : d=f+g := by
+    unfold d f g V; ext i; unfold patched; simp only [Pi.add_apply,Pi.sub_apply]
+    ring
+  rw [hd]
+  refine ⟨shadow_add v q f g ε ε hs (patched_board v j q a V ε hg),?_⟩
+  intro m hN w hw s u hu hz
+  let W (i) := exceeds (v.beyond j) (v.boundTail j q) (V i) (scriptTail s j) m
+    (fun i=>u i.val) ε
+  have he (o) (hf : exceeds v q g s m u ε o) : ∃ i,W i o := by
+    by_contra! hx
+    exact patched_exceed v j q a V ε u hu s m o hx hf
+  have hn := hw.1
+  have hi :
+      pr w (fun x => ∃ i:Fin r,W i x) ≤ (r:ℝ)*y := by
+    refine (pr_exists_le hn.nz W).trans ((Finset.sum_le_sum
+      (g:=fun _=>y) (fun i _=>?_)).trans_eq (by simp))
+    exact hh i m hN w hw (scriptTail s j) _ (fun i =>hu i.val) (fun i =>hz i.val)
+  apply (le_trans (pr_mono hn.nz (fun i => scene_join v q f g s m u _ _ i)) (pr_or_le hn.nz)).trans
+  exact add_le_add (h m hN w hw s u hu hz) ((pr_mono hn.nz he).trans hi)
+end Template
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/ReferenceProductTests.lean

@@ -1,85 +1,85 @@
-import OAI.Combinatorics.HadwigerCounterexample.KeyReferenceLaws
-import OAI.Combinatorics.HadwigerCounterexample.EndpointTemplateConcentration
-
-namespace OAI
-
-/-! # Reference Product Tests -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open scoped BigOperators
-open Matrix Module Function Finset Filter
-variable {p : Shape} {I : Type} [Fintype I] [DecidableEq I] {n N : ℕ}
-
-set_option maxHeartbeats 600000 in
-theorem reference_product (t : Tagging p I) (q : I → F)
-    (f : ∀ i,Wgt (AtomKey (p:=p) (t i) N))
-    (hf : ∀ i x,|f i x|≤1) (hN : 2*num (I×Toast p)-(N:ℝ)≤ -1) :
-    |avg (lawNu p N t q) (prodW f)- ∏ i,avg (lawOmega p N (t i) (q i)) (f i)|≤
-      2*netFact (trayPort p t)*bp (-(N:ℝ)/2) := by
-  classical
-  let F (i : I) := (f i)∘(mug p (t i) N).symm
-  let g := trayPort p t
-  let A := trayMap p t q
-  have hpL i := show 2*num (Port g i)-(N:ℝ)≤ -1 by linarith only [hN,port_limit g i]
-  have he :
-      avg (rackWave A N) (brightProd F) =avg (lawNu p N t q) (prodW f) := by
-    unfold A; rw [←lawtray,mapW_avg]
-    have hh x : brightProd F (tray p t N x)=prodW f x := by
-      simp_rw [brightProd,tray_sips,F,Function.comp_apply,Equiv.symm_apply_apply]
-      rfl
-    simp_rw [hh]
-  have hw i : avg (rackWave (laneM A i) N) (F i)=avg (lawOmega p N (t i) (q i)) (f i) := by
-    unfold A; rw [←lawmug,mapW_avg]
-    simp_rw [F,Function.comp_apply, Equiv.symm_apply_apply]
-  have h := compare_waves A F (fun i x => hf _ _) hpL
-  simp_rw [he,hw] at h; exact h
-
-theorem priceNu (t : Tagging p I) (q : I→F) (hN : 2*num (I×Toast p)-(N:ℝ) ≤ -1) :
-    (netFact (trayPort p t))⁻¹ ≤ pr unif (ownPart (p:=p) t q (N:=N)) := by
-  classical
-  let g := trayPort p t; let A := trayMap p t q
-  have hpL i := show 2*num (Port g i)-(N:ℝ)≤ -1 by linarith only [hN,port_limit g i]
-  have he : pr unif (gramPart A (N:=N))=pr unif (ownPart (p:=p) t q (N:=N)) := by
-    rw [← unif_equiv (tray p t N),mapW_pr]
-    unfold A
-    congr 1; ext i
-    exact (tray_wave ..).symm
-  rw [←he]
-  exact wave_norm A N hpL
-theorem nuLaw (t : Tagging p I) (q : I → F) (hN : 2*num (I×Toast p)-(N:ℝ) ≤ -1) :
-    IsLaw (lawNu p N t q) := by
-  classical
-  rw [lawNu,←on_unif]
-  exact on_law unif_law.nz ((inv_pos_of_pos netFact_pos).trans_le (priceNu t q hN))
-
-theorem priceOmega (t : Tagging p I) (q : I→F) (i : I) (hN : 2*num (I×Toast p)-(N:ℝ) ≤ -1) :
-    (netFact (street (trayPort p t) i))⁻¹ ≤ pr unif (ownOne p (t i) (q i) (N:=N)) := by
-  classical
-  let g := street (trayPort p t) i; let A := laneM (trayMap p t q) i
-  have hh j : num (Port g j)≤num (I×Toast p) := by
-    apply le_trans (port_limit g j)
-    exact_mod_cast Fintype.card_le_of_injective (fun j : Toast p => (i,j)) (fun i j h =>
-      congrArg Prod.snd h)
-  have hpL j := show 2*num (Port g j)-(N:ℝ)≤ -1 by linarith only [hN,hh j]
-  have he : pr unif (gramPart A (N:=N))=pr unif (ownOne p (t i) (q i) (N:=N)) := by
-    rw [← unif_equiv (mug p (t i) N),mapW_pr]
-    unfold A
-    congr 1; ext x
-    exact (mug_wave ..).symm
-  rw [←he]
-  exact wave_norm A N hpL
-
-theorem omegaLaw (p : Shape) (l : Tag p.g) (q : F) (hN : 2*num (Toast p)-(N:ℝ)≤ -1) :
-    IsLaw (lawOmega p N l q) := by
-  classical
-  let t := fun (_ : Unit) => l
-  have hh : 2*num (Unit×Toast p)-(N:ℝ)≤ -1 := by simpa [num] using hN
-  rw [lawOmega,←on_unif]
-  exact on_law unif_law.nz ((inv_pos_of_pos netFact_pos).trans_le
-    (priceOmega t (fun _ : Unit => q) () hh))
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.KeyReferenceLaws
+import OAI.Combinatorics.HadwigerCounterexample.EndpointTemplateConcentration
+
+namespace OAI
+
+/-! # Reference Product Tests -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open scoped BigOperators
+open Matrix Module Function Finset Filter
+variable {p : Shape} {I : Type} [Fintype I] [DecidableEq I] {n N : ℕ}
+
+set_option maxHeartbeats 600000 in
+theorem reference_product (t : Tagging p I) (q : I → F)
+    (f : ∀ i,Wgt (AtomKey (p:=p) (t i) N))
+    (hf : ∀ i x,|f i x|≤1) (hN : 2*num (I×Toast p)-(N:ℝ)≤ -1) :
+    |avg (lawNu p N t q) (prodW f)- ∏ i,avg (lawOmega p N (t i) (q i)) (f i)|≤
+      2*netFact (trayPort p t)*bp (-(N:ℝ)/2) := by
+  classical
+  let F (i : I) := (f i)∘(mug p (t i) N).symm
+  let g := trayPort p t
+  let A := trayMap p t q
+  have hpL i := show 2*num (Port g i)-(N:ℝ)≤ -1 by linarith only [hN,port_limit g i]
+  have he :
+      avg (rackWave A N) (brightProd F) =avg (lawNu p N t q) (prodW f) := by
+    unfold A; rw [←lawtray,mapW_avg]
+    have hh x : brightProd F (tray p t N x)=prodW f x := by
+      simp_rw [brightProd,tray_sips,F,Function.comp_apply,Equiv.symm_apply_apply]
+      rfl
+    simp_rw [hh]
+  have hw i : avg (rackWave (laneM A i) N) (F i)=avg (lawOmega p N (t i) (q i)) (f i) := by
+    unfold A; rw [←lawmug,mapW_avg]
+    simp_rw [F,Function.comp_apply, Equiv.symm_apply_apply]
+  have h := compare_waves A F (fun i x => hf _ _) hpL
+  simp_rw [he,hw] at h; exact h
+
+theorem priceNu (t : Tagging p I) (q : I→F) (hN : 2*num (I×Toast p)-(N:ℝ) ≤ -1) :
+    (netFact (trayPort p t))⁻¹ ≤ pr unif (ownPart (p:=p) t q (N:=N)) := by
+  classical
+  let g := trayPort p t; let A := trayMap p t q
+  have hpL i := show 2*num (Port g i)-(N:ℝ)≤ -1 by linarith only [hN,port_limit g i]
+  have he : pr unif (gramPart A (N:=N))=pr unif (ownPart (p:=p) t q (N:=N)) := by
+    rw [← unif_equiv (tray p t N),mapW_pr]
+    unfold A
+    congr 1; ext i
+    exact (tray_wave ..).symm
+  rw [←he]
+  exact wave_norm A N hpL
+theorem nuLaw (t : Tagging p I) (q : I → F) (hN : 2*num (I×Toast p)-(N:ℝ) ≤ -1) :
+    IsLaw (lawNu p N t q) := by
+  classical
+  rw [lawNu,←on_unif]
+  exact on_law unif_law.nz ((inv_pos_of_pos netFact_pos).trans_le (priceNu t q hN))
+
+theorem priceOmega (t : Tagging p I) (q : I→F) (i : I) (hN : 2*num (I×Toast p)-(N:ℝ) ≤ -1) :
+    (netFact (street (trayPort p t) i))⁻¹ ≤ pr unif (ownOne p (t i) (q i) (N:=N)) := by
+  classical
+  let g := street (trayPort p t) i; let A := laneM (trayMap p t q) i
+  have hh j : num (Port g j)≤num (I×Toast p) := by
+    apply le_trans (port_limit g j)
+    exact_mod_cast Fintype.card_le_of_injective (fun j : Toast p => (i,j)) (fun i j h =>
+      congrArg Prod.snd h)
+  have hpL j := show 2*num (Port g j)-(N:ℝ)≤ -1 by linarith only [hN,hh j]
+  have he : pr unif (gramPart A (N:=N))=pr unif (ownOne p (t i) (q i) (N:=N)) := by
+    rw [← unif_equiv (mug p (t i) N),mapW_pr]
+    unfold A
+    congr 1; ext x
+    exact (mug_wave ..).symm
+  rw [←he]
+  exact wave_norm A N hpL
+
+theorem omegaLaw (p : Shape) (l : Tag p.g) (q : F) (hN : 2*num (Toast p)-(N:ℝ)≤ -1) :
+    IsLaw (lawOmega p N l q) := by
+  classical
+  let t := fun (_ : Unit) => l
+  have hh : 2*num (Unit×Toast p)-(N:ℝ)≤ -1 := by simpa [num] using hN
+  rw [lawOmega,←on_unif]
+  exact on_law unif_law.nz ((inv_pos_of_pos netFact_pos).trans_le
+    (priceOmega t (fun _ : Unit => q) () hh))
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/RefinedPinImages.lean

@@ -1,240 +1,240 @@
-import OAI.Combinatorics.HadwigerCounterexample.PartitionSelection
-import OAI.Combinatorics.HadwigerCounterexample.FourPhaseBits
-
-namespace OAI
-
-/-! # Refined Pin Images -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Matrix LinearMap Module Submodule Function Finset
-open scoped BigOperators
-variable {p : Shape} {n N : ℕ}
-
-def front (s : Plan p n) : Plan p n := prSmall s
-
-theorem front_rank (s : Plan p n) : planRank (front s) ≤2*planRank s := by
-  classical
-  unfold planRank
-  rw [Finset.mul_sum]
-  refine Finset.sum_le_sum fun i _ => ?_
-  have hh (j) :
-      dim ((sPin s i j).map (IP p n j).mulVecLin)≤dim (s i) :=
-    (Submodule.finrank_map_le ..).trans (sPin_dim ..)
-  exact ((Submodule.finrank_add_le_finrank_add_finrank ..).trans (add_le_add (hh _) (hh _))).trans_eq
-    (two_mul _).symm
-
-theorem combined_rank (s t : Plan p n) : planRank (s⊔t)≤planRank s+planRank t := by
-  unfold planRank; rw [←Finset.sum_add_distrib]
-  exact Finset.sum_le_sum fun i _ => finrank_add_le_finrank_add_finrank ..
-
-abbrev Signal (p : Shape) (N : ℕ) {n} (s : Plan p n) := DTuple (p:=p) (fun z => dim (s z)) N
-
-def readPin (x : UnitType p n N) (a : Plan p n) : Signal p N a :=
-  fun z => images x z * pack (a z)
-
-abbrev EffSeq {p : Shape} {n} (s : Plan p n) := ∀ i : Bool,effective s i
-
-def entrySeq {p : Shape} {n} (s : Plan p n) (m : Bool → Profile p n) : EffSeq s :=
-  open scoped Classical in
-  fun i => if h : m i ∈ effective s i then ⟨_,h⟩ else 0
-
-abbrev Story {p : Shape} {n N} (T : Cov p N) (s : Plan p n) :=
-  Daypair p T × Signal p N (front s) × EffSeq s
-
-instance fintypeStory {s : Plan p n} {T : Cov p N} : Fintype (Story T s) := by
-  classical
-  let A := (coverX p T)
-  letI : Finite (Module.Dual F A) := Finite.of_injective _ DFunLike.coe_injective
-  letI : Fintype (Module.Dual F A) := Fintype.ofFinite _
-  letI : Fintype (Daypair p T) := inferInstanceAs (Fintype (Daypair p T))
-  letI : ∀ i,Fintype (effective s i) := fun i => Fintype.ofFinite _
-  letI : Fintype (EffSeq s) := inferInstanceAs (Fintype (EffSeq s))
-  letI : Fintype (Signal p N (front s)) := inferInstanceAs (Fintype (Signal p N (front s)))
-  exact inferInstanceAs (Fintype (Story T s))
-
-def story (T : Cov p N) (s : Plan p n) (m : BMark p n N) (x : UnitType p n N) : Story T s :=
-  (daypair p T (delta m) (fun _ => 1) x,readPin x (front s),entrySeq s (m x))
-
-def specialLeaf (T : Cov p N) (m : BMark p n N) (a : Pin p n N)
-    (G : CTile p n N) (b : Pin p n N) :=
-  a.sp ≤ b.sp ∧ front a.sp ≤ b.sp ∧
-    ∀ x∈G,∀ y∈G, m x=m y ∧ delta m x=delta m y ∧
-      ∀ i,juris p T x (unary i) = juris p T y (unary i)
-
-private theorem storyOk (T : Cov p N) (m : BMark p n N)
-    (a : Pin p n N) (S : CTile p n N) (K : ℕ) (hk : planRank a.sp≤K)
-    (h : ∀ x∈S, a.agree x ∧ covered p T (delta m x) ∧
-       ∀ i,m x i∈effective a.sp i) :
-    ∀ i : Story T a.sp,∃ b : Pin p n N,
-       (∀ x∈ S,story T a.sp m x=i → b.agree x) ∧ planRank b.sp ≤ 3*K ∧
-       ∀ c (G : CTile p n N), G.Nonempty →
-         (∀ x∈G,x∈S ∧ story T a.sp m x=i) → b.sp ≤ c.sp → specialLeaf T m a G c := by
-  classical
-  intro i
-  let A := a.sp ⊔ front a.sp
-  have hK : planRank A≤3*K := by
-    apply (combined_rank ..).trans
-    have hh := front_rank a.sp
-    omega
-  have h1 : ∃ x : UnitType p n N, ∀ y∈ S,story T a.sp m y=i → (Pin.make A x).agree y := by
-    by_cases hg : ∃ x∈S,story T a.sp m x=i
-    · obtain ⟨x,hx,he⟩ := hg
-      refine ⟨x,fun y hy ht => ?_⟩
-      let b := Pin.make (front a.sp) x
-      have hf : b.agree y := by
-        rw [Pin.agree_pack]; intro z
-        have hh : readPin y (front a.sp)=readPin x (front a.sp) :=
-          congrArg (fun x : Story T a.sp => x.2.1) (ht.trans he.symm)
-        exact congr_fun hh z
-      exact (Pin.combine (b:=b) (h x hx).1 (show b.agree x from fun _ _ _ => rfl)).mpr
-        ⟨(h y hy).1,hf⟩
-    exact ⟨0,fun x hx he => (hg ⟨x,hx,he⟩).elim⟩
-  obtain ⟨x,hx⟩ := h1
-  refine ⟨Pin.make A x,hx,hK,fun c G hm hC hA => ⟨le_trans le_sup_left hA,
-    le_trans le_sup_right hA, fun x hx y hy => ?_⟩⟩
-  have he := (hC x hx).2.trans (hC y hy).2.symm
-  have hD := congrArg Prod.fst he
-  have hr z (hz : z∈G) : (story T a.sp m z).1.1.val=delta m z := by
-    unfold story daypair; change (cutDown p T (delta m) (fun _ => 1) z).val=_
-    unfold cutDown; rw [dite_eq_left ⟨(by norm_num),(h z (hC z hz).1).2.1⟩]
-  have ht z (hz : z∈G) (i) : ((story T a.sp m z).2.2 i).val=m z i := by
-    unfold story entrySeq; dsimp only
-    rw [dite_eq_left ((h z (hC z hz).1).2.2 i)]
-  refine ⟨funext (fun i => ?_),?_,fun i => ?_⟩
-  · rw [←ht x hx i,←ht y hy i,he]
-  · rw [←hr x hx, ←hr y hy,he]
-  exact congr_fun (congrArg Prod.snd hD) i
-
-theorem story_size (T : Cov p N) (s : Plan p n) (K d : ℕ)
-    (hK : planRank s≤K) (hd : cdim p T≤d) :
-    num (Story T s) ≤ bp ((3*d+2*K : ℝ)*N + 2*K^2) := by
-  classical
-  have h1 : dim (coverX p T)≤ N*d := (cover_dim p T).trans (Nat.mul_le_mul_left N hd)
-  have h2 : dim (Daypair p T) ≤ 3*d*N := by
-    unfold dim Daypair
-    rw [finrank_prod,finrank_pi_fintype, Fintype.sum_bool,Subspace.dual_finrank_eq]
-    change dim _+(dim _+dim _) ≤ _
-    nlinarith
-  have h3 : dim (Signal p N (front s)) ≤ (2*K)*N := tuple_dim.trans_le (by
-    rw [mul_comm]; apply Nat.mul_le_mul_right
-    exact (front_rank s).trans (Nat.mul_le_mul_left _ hK))
-  have h4 : dim (EffSeq s)≤ 2*K^2 := by
-    unfold EffSeq dim
-    rw [finrank_pi_fintype,Fintype.sum_bool,two_mul]
-    have hh i : dim (effective s i) ≤ K^2 := (effective_dim ..).trans (by gcongr)
-    exact add_le_add (hh _) (hh _)
-  unfold num
-  rw [card_space]
-  apply bp_le
-  have hh : dim (Story T s)≤ (3*d+2*K)*N+2*K^2 := by
-    unfold Story dim; rw [finrank_prod, finrank_prod (M:=Signal p N (front s))]
-    change dim (Daypair p T)+(dim (Signal p N (front s))+dim (EffSeq s)) ≤ _
-    rw [Nat.add_mul,add_assoc]
-    exact add_le_add h2 (add_le_add h3 h4)
-  exact_mod_cast hh
-
-theorem plan_inc_eff (s t : Plan p n) (h : s ≤ t) (i : Bool) :
-    effective s i≤effective t i := by
-  intro x hx
-  obtain ⟨h1,h2⟩ := effective_mem.mp hx
-  have he z : sPin s z i ≤ sPin t z i := Submodule.map_mono (h z)
-  exact effective_mem.mpr ⟨h1,fun z => box_le (he _) (he _) (h2 _)⟩
-
-/-- Old contractions on admissible tables evaluate correctly when
-the enlarged leaf has pinned the entire front. -/
-theorem front_table (x y : UnitType p n N)
-    {a b : Pin p n N} (s : Plan p n)
-    (hf : front s≤a.sp)
-    {M : Cross p n} (hx : a.agree x) (hB : tableFlag b a (reciprocal p M) y)
-    (i j : Bool) (w : Profile p n) (h : w∈effective s i) :
-    contract p (actual p x y) i j w=contract p M i j w := by
-  have hz (z) (u : Dir p n) (hu : u∈a.sp z) :
-      channelOut p M j z *ᵥ u=channelOut p (actual p x y) j z *ᵥ u := by
-    refine channel_same j z u (fun v => ?_)
-    have h1 : IH p n j *ᵥ v∈tabSpace b.sp (flipZ p z) :=
-      channel_le_table b.sp _ _ ⟨_,rfl⟩
-    have h2 : u∈a.sp (flipZ p (flipZ p z)) := by rwa [flipZ_flip]
-    have he := hB (flipZ p z) _ h1 _ h2
-    have hg := flag_actual (a:=b) y x hx (flipZ p z) _ h1 _ h2
-    rw [← reciprocal_actual x y] at hg
-    simp only [reciprocal,flipZ_flip,evmat_transpose] at he hg
-    exact he.trans hg.symm
-  have he z : (sPin s z i).map (IP p n i).mulVecLin ≤ a.sp z := by
-    apply le_trans _ (hf z)
-    cases i; exact le_sup_right; exact le_sup_left
-  change ∑ e, _=_
-  refine Finset.sum_congr rfl fun e _ => ?_
-  refine (box_eval_iff (a.sp (e,true)) (a.sp (e,false)) _ _).mp ?_ _
-    (box_le (he _) (he _) (lift_mem_box _ _ ((effective_mem.mp h).2 e)))
-  intro x hx y hy
-  rw [ev_duom,ev_duom,hz _ _ hx,hz _ _ hy]
-
-set_option maxHeartbeats 900000 in
-theorem weave (P : UnitType p n N→Prop)
-    {w μ : Wgt (UnitType p n N)}
-    (m : BMark p n N) (T : Cov p N)
-    (hw : ∀ x,0≤w x) {D ζ u : ℝ} (hz : 0 < ζ) (hz' : ζ<1) {K K' d : ℕ}
-    (hn : 0<N)
-    (hμ : ∀ a : Pin p n N,pr μ a.agree ≤ fee N (ζ/4) (planRank a.sp))
-    (hd : cdim p T≤d)
-    {F : Canopy p n N} (hT : apart F) (g : CTile p n N → Pin p n N)
-    (h : ∀ i∈F,Ripe p w μ i (g i) D ζ K)
-    (hg : ∀ i∈ F,∀ x∈i,P x→covered p T (delta m x) ∧ ∀ j,m x j∈effective (g i).sp j)
-    (hk : D+u+ζ≤(ζ-ζ/4)*K')
-    (hu : (3*d+2*K:ℝ)*N+2*K^2 ≤ (u-1)*N) :
-    ∃ V : Canopy p n N,apart V ∧
-    (∀ S∈V,∃ i∈F,S⊆i ∧ (∀ x∈ S,P x) ∧
-      ∃ b : Pin p n N,Ripe p w μ S b (D+u+K'+1) ζ (3*K+K') ∧ specialLeaf T m (g i) S b) ∧
-    pr w (fun x => inTiles F x ∧ P x ∧ ¬inTiles V x) ≤
-      allMass w F*(bp (-(N:ℝ))+bp (-ζ*N)) := by
-  classical
-  refine improve F w hw P
-    (fun i S => (∀ x∈ S,P x) ∧ ∃ b : Pin p n N,Ripe p w μ S b (D+u+K'+1) ζ (3*K+K') ∧
-      specialLeaf T m (g i) S b)
-    hT (fun i hi => ?_)
-  let A := CTile p n N
-  let S := i.filter P
-  let Q := specialLeaf T m (g i)
-  have hs (x : UnitType p n N) : x∈S↔ x∈i∧ P x := Finset.mem_filter
-  have hq := h i hi
-  let w' := partW w i
-  have hw' : IsLaw w' := on_law hw hq.pos
-  have hg : ∀ x∈ S,(g i).agree x∧ covered p T (delta m x)∧∀ j,m x j∈effective (g i).sp j :=
-    fun x h => ⟨hq.fixpin _ ((hs ..).mp h).1,hg i hi x ((hs ..).mp h).1 ((hs ..).mp h).2⟩
-  obtain ⟨V,hV,hX,hZ⟩ := reparts w' μ hw' S D ζ u hn hz hz' hμ hq.density
-    (story T (g i).sp m) (3*K) K' Q
-    (storyOk T m (g i) S K hq.bound hg) hk
-  refine ⟨V,hV,fun x hx => ?_,?_⟩
-  · obtain ⟨hS,b,hB,hL⟩ := hX x hx
-    have hx' : x⊆i := hS.trans (Finset.filter_subset ..)
-    obtain ⟨he,hLaw⟩ := issued_law w hw hq.pos hx' hB.pos
-    refine ⟨hx', (fun z hz => ((hs ..).mp (hS hz)).2),b,⟨he,hB.fixpin,hB.bound,?_,?_⟩,hL⟩
-    · rw [hLaw]; exact hB.clear
-    rw [hLaw]; exact hB.density
-  simp_rw [hs,and_assoc] at hZ
-  refine hZ.trans (add_le_add_left ?_ _)
-  refine (mul_le_mul_of_nonneg_right (story_size T _ K d hq.bound hd) (bp_pos _).le).trans ?_
-  rw [←bp_add]; apply bp_le
-  linarith only [hu]
-
-theorem phase_fixed (m : BMark p n N) (T : Cov p N)
-    (A A' B B' : Pin p n N) {S R : CTile p n N}
-    {x x' y y' : UnitType p n N}
-    (h : specialLeaf T m A S A') (hg : specialLeaf T m B R B')
-    (hx : x∈S) (hx' : x'∈S) (hy : y∈R) (hy' : y'∈R)
-    (hC : covered p T (delta m x)) (hC' : covered p T (delta m y)) :
-    quench p (delta m) (x,y)=quench p (delta m) (x',y') := by
-  obtain ⟨_,h1,h2⟩ := h.2.2 x hx x' hx'
-  obtain ⟨_,h3,h4⟩ := hg.2.2 y hy y' hy'
-  unfold quench; dsimp only
-  rw [← h1, ← h3]
-  exact Prod.ext
-    (funext fun i => LinearMap.congr_fun (h4 i) (⟨_,hC⟩ : coverX p T))
-    (funext fun i => LinearMap.congr_fun (h2 i) (⟨_,hC'⟩ : coverX p T))
-
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.PartitionSelection
+import OAI.Combinatorics.HadwigerCounterexample.FourPhaseBits
+
+namespace OAI
+
+/-! # Refined Pin Images -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Matrix LinearMap Module Submodule Function Finset
+open scoped BigOperators
+variable {p : Shape} {n N : ℕ}
+
+def front (s : Plan p n) : Plan p n := prSmall s
+
+theorem front_rank (s : Plan p n) : planRank (front s) ≤2*planRank s := by
+  classical
+  unfold planRank
+  rw [Finset.mul_sum]
+  refine Finset.sum_le_sum fun i _ => ?_
+  have hh (j) :
+      dim ((sPin s i j).map (IP p n j).mulVecLin)≤dim (s i) :=
+    (Submodule.finrank_map_le ..).trans (sPin_dim ..)
+  exact ((Submodule.finrank_add_le_finrank_add_finrank ..).trans (add_le_add (hh _) (hh _))).trans_eq
+    (two_mul _).symm
+
+theorem combined_rank (s t : Plan p n) : planRank (s⊔t)≤planRank s+planRank t := by
+  unfold planRank; rw [←Finset.sum_add_distrib]
+  exact Finset.sum_le_sum fun i _ => finrank_add_le_finrank_add_finrank ..
+
+abbrev Signal (p : Shape) (N : ℕ) {n} (s : Plan p n) := DTuple (p:=p) (fun z => dim (s z)) N
+
+def readPin (x : UnitType p n N) (a : Plan p n) : Signal p N a :=
+  fun z => images x z * pack (a z)
+
+abbrev EffSeq {p : Shape} {n} (s : Plan p n) := ∀ i : Bool,effective s i
+
+def entrySeq {p : Shape} {n} (s : Plan p n) (m : Bool → Profile p n) : EffSeq s :=
+  open scoped Classical in
+  fun i => if h : m i ∈ effective s i then ⟨_,h⟩ else 0
+
+abbrev Story {p : Shape} {n N} (T : Cov p N) (s : Plan p n) :=
+  Daypair p T × Signal p N (front s) × EffSeq s
+
+instance fintypeStory {s : Plan p n} {T : Cov p N} : Fintype (Story T s) := by
+  classical
+  let A := (coverX p T)
+  letI : Finite (Module.Dual F A) := Finite.of_injective _ DFunLike.coe_injective
+  letI : Fintype (Module.Dual F A) := Fintype.ofFinite _
+  letI : Fintype (Daypair p T) := inferInstanceAs (Fintype (Daypair p T))
+  letI : ∀ i,Fintype (effective s i) := fun i => Fintype.ofFinite _
+  letI : Fintype (EffSeq s) := inferInstanceAs (Fintype (EffSeq s))
+  letI : Fintype (Signal p N (front s)) := inferInstanceAs (Fintype (Signal p N (front s)))
+  exact inferInstanceAs (Fintype (Story T s))
+
+def story (T : Cov p N) (s : Plan p n) (m : BMark p n N) (x : UnitType p n N) : Story T s :=
+  (daypair p T (delta m) (fun _ => 1) x,readPin x (front s),entrySeq s (m x))
+
+def specialLeaf (T : Cov p N) (m : BMark p n N) (a : Pin p n N)
+    (G : CTile p n N) (b : Pin p n N) :=
+  a.sp ≤ b.sp ∧ front a.sp ≤ b.sp ∧
+    ∀ x∈G,∀ y∈G, m x=m y ∧ delta m x=delta m y ∧
+      ∀ i,juris p T x (unary i) = juris p T y (unary i)
+
+private theorem storyOk (T : Cov p N) (m : BMark p n N)
+    (a : Pin p n N) (S : CTile p n N) (K : ℕ) (hk : planRank a.sp≤K)
+    (h : ∀ x∈S, a.agree x ∧ covered p T (delta m x) ∧
+       ∀ i,m x i∈effective a.sp i) :
+    ∀ i : Story T a.sp,∃ b : Pin p n N,
+       (∀ x∈ S,story T a.sp m x=i → b.agree x) ∧ planRank b.sp ≤ 3*K ∧
+       ∀ c (G : CTile p n N), G.Nonempty →
+         (∀ x∈G,x∈S ∧ story T a.sp m x=i) → b.sp ≤ c.sp → specialLeaf T m a G c := by
+  classical
+  intro i
+  let A := a.sp ⊔ front a.sp
+  have hK : planRank A≤3*K := by
+    apply (combined_rank ..).trans
+    have hh := front_rank a.sp
+    omega
+  have h1 : ∃ x : UnitType p n N, ∀ y∈ S,story T a.sp m y=i → (Pin.make A x).agree y := by
+    by_cases hg : ∃ x∈S,story T a.sp m x=i
+    · obtain ⟨x,hx,he⟩ := hg
+      refine ⟨x,fun y hy ht => ?_⟩
+      let b := Pin.make (front a.sp) x
+      have hf : b.agree y := by
+        rw [Pin.agree_pack]; intro z
+        have hh : readPin y (front a.sp)=readPin x (front a.sp) :=
+          congrArg (fun x : Story T a.sp => x.2.1) (ht.trans he.symm)
+        exact congr_fun hh z
+      exact (Pin.combine (b:=b) (h x hx).1 (show b.agree x from fun _ _ _ => rfl)).mpr
+        ⟨(h y hy).1,hf⟩
+    exact ⟨0,fun x hx he => (hg ⟨x,hx,he⟩).elim⟩
+  obtain ⟨x,hx⟩ := h1
+  refine ⟨Pin.make A x,hx,hK,fun c G hm hC hA => ⟨le_trans le_sup_left hA,
+    le_trans le_sup_right hA, fun x hx y hy => ?_⟩⟩
+  have he := (hC x hx).2.trans (hC y hy).2.symm
+  have hD := congrArg Prod.fst he
+  have hr z (hz : z∈G) : (story T a.sp m z).1.1.val=delta m z := by
+    unfold story daypair; change (cutDown p T (delta m) (fun _ => 1) z).val=_
+    unfold cutDown; rw [dite_eq_left ⟨(by norm_num),(h z (hC z hz).1).2.1⟩]
+  have ht z (hz : z∈G) (i) : ((story T a.sp m z).2.2 i).val=m z i := by
+    unfold story entrySeq; dsimp only
+    rw [dite_eq_left ((h z (hC z hz).1).2.2 i)]
+  refine ⟨funext (fun i => ?_),?_,fun i => ?_⟩
+  · rw [←ht x hx i,←ht y hy i,he]
+  · rw [←hr x hx, ←hr y hy,he]
+  exact congr_fun (congrArg Prod.snd hD) i
+
+theorem story_size (T : Cov p N) (s : Plan p n) (K d : ℕ)
+    (hK : planRank s≤K) (hd : cdim p T≤d) :
+    num (Story T s) ≤ bp ((3*d+2*K : ℝ)*N + 2*K^2) := by
+  classical
+  have h1 : dim (coverX p T)≤ N*d := (cover_dim p T).trans (Nat.mul_le_mul_left N hd)
+  have h2 : dim (Daypair p T) ≤ 3*d*N := by
+    unfold dim Daypair
+    rw [finrank_prod,finrank_pi_fintype, Fintype.sum_bool,Subspace.dual_finrank_eq]
+    change dim _+(dim _+dim _) ≤ _
+    nlinarith
+  have h3 : dim (Signal p N (front s)) ≤ (2*K)*N := tuple_dim.trans_le (by
+    rw [mul_comm]; apply Nat.mul_le_mul_right
+    exact (front_rank s).trans (Nat.mul_le_mul_left _ hK))
+  have h4 : dim (EffSeq s)≤ 2*K^2 := by
+    unfold EffSeq dim
+    rw [finrank_pi_fintype,Fintype.sum_bool,two_mul]
+    have hh i : dim (effective s i) ≤ K^2 := (effective_dim ..).trans (by gcongr)
+    exact add_le_add (hh _) (hh _)
+  unfold num
+  rw [card_space]
+  apply bp_le
+  have hh : dim (Story T s)≤ (3*d+2*K)*N+2*K^2 := by
+    unfold Story dim; rw [finrank_prod, finrank_prod (M:=Signal p N (front s))]
+    change dim (Daypair p T)+(dim (Signal p N (front s))+dim (EffSeq s)) ≤ _
+    rw [Nat.add_mul,add_assoc]
+    exact add_le_add h2 (add_le_add h3 h4)
+  exact_mod_cast hh
+
+theorem plan_inc_eff (s t : Plan p n) (h : s ≤ t) (i : Bool) :
+    effective s i≤effective t i := by
+  intro x hx
+  obtain ⟨h1,h2⟩ := effective_mem.mp hx
+  have he z : sPin s z i ≤ sPin t z i := Submodule.map_mono (h z)
+  exact effective_mem.mpr ⟨h1,fun z => box_le (he _) (he _) (h2 _)⟩
+
+/-- Old contractions on admissible tables evaluate correctly when
+the enlarged leaf has pinned the entire front. -/
+theorem front_table (x y : UnitType p n N)
+    {a b : Pin p n N} (s : Plan p n)
+    (hf : front s≤a.sp)
+    {M : Cross p n} (hx : a.agree x) (hB : tableFlag b a (reciprocal p M) y)
+    (i j : Bool) (w : Profile p n) (h : w∈effective s i) :
+    contract p (actual p x y) i j w=contract p M i j w := by
+  have hz (z) (u : Dir p n) (hu : u∈a.sp z) :
+      channelOut p M j z *ᵥ u=channelOut p (actual p x y) j z *ᵥ u := by
+    refine channel_same j z u (fun v => ?_)
+    have h1 : IH p n j *ᵥ v∈tabSpace b.sp (flipZ p z) :=
+      channel_le_table b.sp _ _ ⟨_,rfl⟩
+    have h2 : u∈a.sp (flipZ p (flipZ p z)) := by rwa [flipZ_flip]
+    have he := hB (flipZ p z) _ h1 _ h2
+    have hg := flag_actual (a:=b) y x hx (flipZ p z) _ h1 _ h2
+    rw [← reciprocal_actual x y] at hg
+    simp only [reciprocal,flipZ_flip,evmat_transpose] at he hg
+    exact he.trans hg.symm
+  have he z : (sPin s z i).map (IP p n i).mulVecLin ≤ a.sp z := by
+    apply le_trans _ (hf z)
+    cases i; exact le_sup_right; exact le_sup_left
+  change ∑ e, _=_
+  refine Finset.sum_congr rfl fun e _ => ?_
+  refine (box_eval_iff (a.sp (e,true)) (a.sp (e,false)) _ _).mp ?_ _
+    (box_le (he _) (he _) (lift_mem_box _ _ ((effective_mem.mp h).2 e)))
+  intro x hx y hy
+  rw [ev_duom,ev_duom,hz _ _ hx,hz _ _ hy]
+
+set_option maxHeartbeats 900000 in
+theorem weave (P : UnitType p n N→Prop)
+    {w μ : Wgt (UnitType p n N)}
+    (m : BMark p n N) (T : Cov p N)
+    (hw : ∀ x,0≤w x) {D ζ u : ℝ} (hz : 0 < ζ) (hz' : ζ<1) {K K' d : ℕ}
+    (hn : 0<N)
+    (hμ : ∀ a : Pin p n N,pr μ a.agree ≤ fee N (ζ/4) (planRank a.sp))
+    (hd : cdim p T≤d)
+    {F : Canopy p n N} (hT : apart F) (g : CTile p n N → Pin p n N)
+    (h : ∀ i∈F,Ripe p w μ i (g i) D ζ K)
+    (hg : ∀ i∈ F,∀ x∈i,P x→covered p T (delta m x) ∧ ∀ j,m x j∈effective (g i).sp j)
+    (hk : D+u+ζ≤(ζ-ζ/4)*K')
+    (hu : (3*d+2*K:ℝ)*N+2*K^2 ≤ (u-1)*N) :
+    ∃ V : Canopy p n N,apart V ∧
+    (∀ S∈V,∃ i∈F,S⊆i ∧ (∀ x∈ S,P x) ∧
+      ∃ b : Pin p n N,Ripe p w μ S b (D+u+K'+1) ζ (3*K+K') ∧ specialLeaf T m (g i) S b) ∧
+    pr w (fun x => inTiles F x ∧ P x ∧ ¬inTiles V x) ≤
+      allMass w F*(bp (-(N:ℝ))+bp (-ζ*N)) := by
+  classical
+  refine improve F w hw P
+    (fun i S => (∀ x∈ S,P x) ∧ ∃ b : Pin p n N,Ripe p w μ S b (D+u+K'+1) ζ (3*K+K') ∧
+      specialLeaf T m (g i) S b)
+    hT (fun i hi => ?_)
+  let A := CTile p n N
+  let S := i.filter P
+  let Q := specialLeaf T m (g i)
+  have hs (x : UnitType p n N) : x∈S↔ x∈i∧ P x := Finset.mem_filter
+  have hq := h i hi
+  let w' := partW w i
+  have hw' : IsLaw w' := on_law hw hq.pos
+  have hg : ∀ x∈ S,(g i).agree x∧ covered p T (delta m x)∧∀ j,m x j∈effective (g i).sp j :=
+    fun x h => ⟨hq.fixpin _ ((hs ..).mp h).1,hg i hi x ((hs ..).mp h).1 ((hs ..).mp h).2⟩
+  obtain ⟨V,hV,hX,hZ⟩ := reparts w' μ hw' S D ζ u hn hz hz' hμ hq.density
+    (story T (g i).sp m) (3*K) K' Q
+    (storyOk T m (g i) S K hq.bound hg) hk
+  refine ⟨V,hV,fun x hx => ?_,?_⟩
+  · obtain ⟨hS,b,hB,hL⟩ := hX x hx
+    have hx' : x⊆i := hS.trans (Finset.filter_subset ..)
+    obtain ⟨he,hLaw⟩ := issued_law w hw hq.pos hx' hB.pos
+    refine ⟨hx', (fun z hz => ((hs ..).mp (hS hz)).2),b,⟨he,hB.fixpin,hB.bound,?_,?_⟩,hL⟩
+    · rw [hLaw]; exact hB.clear
+    rw [hLaw]; exact hB.density
+  simp_rw [hs,and_assoc] at hZ
+  refine hZ.trans (add_le_add_left ?_ _)
+  refine (mul_le_mul_of_nonneg_right (story_size T _ K d hq.bound hd) (bp_pos _).le).trans ?_
+  rw [←bp_add]; apply bp_le
+  linarith only [hu]
+
+theorem phase_fixed (m : BMark p n N) (T : Cov p N)
+    (A A' B B' : Pin p n N) {S R : CTile p n N}
+    {x x' y y' : UnitType p n N}
+    (h : specialLeaf T m A S A') (hg : specialLeaf T m B R B')
+    (hx : x∈S) (hx' : x'∈S) (hy : y∈R) (hy' : y'∈R)
+    (hC : covered p T (delta m x)) (hC' : covered p T (delta m y)) :
+    quench p (delta m) (x,y)=quench p (delta m) (x',y') := by
+  obtain ⟨_,h1,h2⟩ := h.2.2 x hx x' hx'
+  obtain ⟨_,h3,h4⟩ := hg.2.2 y hy y' hy'
+  unfold quench; dsimp only
+  rw [← h1, ← h3]
+  exact Prod.ext
+    (funext fun i => LinearMap.congr_fun (h4 i) (⟨_,hC⟩ : coverX p T))
+    (funext fun i => LinearMap.congr_fun (h2 i) (⟨_,hC'⟩ : coverX p T))
+
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/RefinementEnergy.lean

@@ -1,105 +1,105 @@
-import OAI.Combinatorics.HadwigerCounterexample.InformationSmallSetBounds
-
-namespace OAI
-
-/-! # Refinement Energy -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Finset Filter Real
-open scoped BigOperators
-variable {A B C D : Type} [Fintype A] [Fintype B] [Fintype C] [Fintype D]
-
-theorem var_nonneg (p q : Wgt A) : 0≤ varOne p q := Finset.sum_nonneg fun _ _ => abs_nonneg _
-theorem var_tri (p q r : Wgt A) :
-    varOne p q≤varOne p r+varOne r q := by
-  unfold varOne; rw [← Finset.sum_add_distrib]; exact sum_le_sum fun i _ => abs_sub_le _ _ _
-
-theorem var_pr (p q : Wgt A) (P : A→Prop) :
-    pr p P-pr q P ≤ varOne p q := by
-  unfold pr avg varOne
-  rw [← Finset.sum_sub_distrib]
-  refine sum_le_sum fun i _ => ?_
-  by_cases h : P i
-  · simp only [ind_one h,mul_one]; exact le_abs_self _
-  simp only [ind_zero h,mul_zero,sub_zero]; exact abs_nonneg _
-
-theorem var_event (p q : Wgt A) (h : tot p=tot q) :
-    let P := fun i => q i<p i
-    varOne p q=2*(pr p P-pr q P) := by
-  intro P
-  have hi (i:A) : |p i-q i|=
-      2*(p i*ind (P i)-q i*ind (P i))+q i-p i := by
-    by_cases h : P i
-    · rw [ind_one h,abs_of_pos (sub_pos.mpr h)]; ring
-    rw [ind_zero h,abs_of_nonpos (sub_nonpos.mpr (le_of_not_gt h))]; ring
-  unfold varOne pr avg
-  simp_rw [hi,Finset.sum_sub_distrib,Finset.sum_add_distrib,← Finset.mul_sum,
-    Finset.sum_sub_distrib]
-  rw [show ∑ i,q i=∑ i,p i from h.symm]; ring
-
-theorem var_mix {μ : Wgt A} (p q : A→Wgt B) (hμ : ∀ i,0≤μ i) :
-    varOne (mixW μ p) (mixW μ q) ≤ avg μ (fun i => varOne (p i) (q i)) := by
-  unfold varOne mixW
-  rw [avg_sum]
-  simp_rw [←avg_sub]; exact sum_le_sum fun i _ => abs_avg_le hμ
-
-omit [Fintype D] in
-theorem bucket_m (μ : Wgt A) (p : A → Wgt B) (f : B→C) (g : C→D) :
-    mapW (bucket unif (g∘f) (mixW μ p)) f =
-      mixW μ (fun x => bucket (mapW unif f) g (mapW (p x) f)) := by
-  rw [bucket_mix,map_mix]
-  simp only [bucket_nested]
-
-variable {μ : Wgt A} {p : A→Wgt B}
-
-theorem tariffs_monotone {r s : ℕ} {a b V : ℝ} (h : tariffs μ p r a V)
-    (hrs : s≤r) (hb : a ≤ b) : tariffs μ p s b V :=
-  fun C _ hC f hf => h C (hC.trans hrs) f (fun _ hi => hb.trans (hf _ hi))
-
-theorem budget_nonneg [Nonempty B] (h : Ultra μ p) (f : B→ C) :
-    0≤budget μ p f := by
-  have h0 {p : Wgt B} : lsupp p unif := fun i _ => by rw [unif_apply]; positivity
-  have hv : IsLaw (mapW unif f) := mapW_law unif_law f
-  exact avg_nonneg h.law.nz (fun i => tension_nonneg (mapW_law (h.labs i) f) hv
-    (lsupp.map h0 unif_law.nz f))
-
-set_option maxHeartbeats 800000 in
-theorem budget_progress [Nonempty B] (h : Ultra μ p) (w : Wgt B)
-    (hw : catalog μ p w) (f : B→C) (g : C→D) :
-    varOne (mapW w f) (mapW (bucket unif (g∘f) w) f) ^ 2 ≤
-      (budget μ p f-budget μ p (g∘f))*4 := by
-  classical
-  let q := mapW unif f
-  let Q (i : A) := mapW (p i) f
-  let R (i : A) := bucket q g (Q i)
-  have hu : IsLaw q := mapW_law unif_law f
-  have hQ (i) : IsLaw (Q i) := mapW_law (h.labs i) f
-  have he (i) : lsupp (Q i) q := lsupp.map
-    (p:=p i) (q:=unif) (fun i _ => by rw [unif_apply]; positivity) unif_law.nz f
-  have hp (i : A) :
-      varOne (Q i) (R i) ^ 2 ≤ tension (Q i) (R i) *4 :=
-    var_tension _ _ (hQ i) (bucket_law (hQ i) g hu.nz (he i))
-      (lsupp_bucket g (hQ i).nz hu.nz (he i))
-  have hn :
-      budget μ p f=avg μ (fun i => tension (Q i) (R i))+budget μ p (g∘f) := by
-    unfold budget
-    have hi := fun i : A => tension_stage (Q i) q (hQ i).nz hu.nz (he i) g
-    unfold Q q at hi
-    simp_rw [map_nested] at hi
-    rw [← avg_add]; exact avg_congr fun i _ => hi i
-  let Z (i : A) := varOne (Q i) (R i)
-  have hs : avg μ Z ^ 2 ≤ avg μ (fun i => Z i ^ 2) := by
-    have hh := avg_CS h.law.nz Z (fun _ => 1)
-    simp only [mul_one,one_pow,h.law.avg_const] at hh; exact hh
-  obtain ⟨s,hs',ht,rfl⟩ := hw
-  rw [bucket_m,map_mix]
-  have h' := (var_mix Q R hs').trans (avg_mono_left (fun i => var_nonneg ..) ht)
-  refine (pow_le_pow_left₀ (var_nonneg ..) h' 2).trans (hs.trans ?_)
-  have hz := avg_mono h.law.nz hp; rw [avg_mul] at hz
-  rw [hn]; exact hz.trans_eq (by ring)
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.InformationSmallSetBounds
+
+namespace OAI
+
+/-! # Refinement Energy -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Finset Filter Real
+open scoped BigOperators
+variable {A B C D : Type} [Fintype A] [Fintype B] [Fintype C] [Fintype D]
+
+theorem var_nonneg (p q : Wgt A) : 0≤ varOne p q := Finset.sum_nonneg fun _ _ => abs_nonneg _
+theorem var_tri (p q r : Wgt A) :
+    varOne p q≤varOne p r+varOne r q := by
+  unfold varOne; rw [← Finset.sum_add_distrib]; exact sum_le_sum fun i _ => abs_sub_le _ _ _
+
+theorem var_pr (p q : Wgt A) (P : A→Prop) :
+    pr p P-pr q P ≤ varOne p q := by
+  unfold pr avg varOne
+  rw [← Finset.sum_sub_distrib]
+  refine sum_le_sum fun i _ => ?_
+  by_cases h : P i
+  · simp only [ind_one h,mul_one]; exact le_abs_self _
+  simp only [ind_zero h,mul_zero,sub_zero]; exact abs_nonneg _
+
+theorem var_event (p q : Wgt A) (h : tot p=tot q) :
+    let P := fun i => q i<p i
+    varOne p q=2*(pr p P-pr q P) := by
+  intro P
+  have hi (i:A) : |p i-q i|=
+      2*(p i*ind (P i)-q i*ind (P i))+q i-p i := by
+    by_cases h : P i
+    · rw [ind_one h,abs_of_pos (sub_pos.mpr h)]; ring
+    rw [ind_zero h,abs_of_nonpos (sub_nonpos.mpr (le_of_not_gt h))]; ring
+  unfold varOne pr avg
+  simp_rw [hi,Finset.sum_sub_distrib,Finset.sum_add_distrib,← Finset.mul_sum,
+    Finset.sum_sub_distrib]
+  rw [show ∑ i,q i=∑ i,p i from h.symm]; ring
+
+theorem var_mix {μ : Wgt A} (p q : A→Wgt B) (hμ : ∀ i,0≤μ i) :
+    varOne (mixW μ p) (mixW μ q) ≤ avg μ (fun i => varOne (p i) (q i)) := by
+  unfold varOne mixW
+  rw [avg_sum]
+  simp_rw [←avg_sub]; exact sum_le_sum fun i _ => abs_avg_le hμ
+
+omit [Fintype D] in
+theorem bucket_m (μ : Wgt A) (p : A → Wgt B) (f : B→C) (g : C→D) :
+    mapW (bucket unif (g∘f) (mixW μ p)) f =
+      mixW μ (fun x => bucket (mapW unif f) g (mapW (p x) f)) := by
+  rw [bucket_mix,map_mix]
+  simp only [bucket_nested]
+
+variable {μ : Wgt A} {p : A→Wgt B}
+
+theorem tariffs_monotone {r s : ℕ} {a b V : ℝ} (h : tariffs μ p r a V)
+    (hrs : s≤r) (hb : a ≤ b) : tariffs μ p s b V :=
+  fun C _ hC f hf => h C (hC.trans hrs) f (fun _ hi => hb.trans (hf _ hi))
+
+theorem budget_nonneg [Nonempty B] (h : Ultra μ p) (f : B→ C) :
+    0≤budget μ p f := by
+  have h0 {p : Wgt B} : lsupp p unif := fun i _ => by rw [unif_apply]; positivity
+  have hv : IsLaw (mapW unif f) := mapW_law unif_law f
+  exact avg_nonneg h.law.nz (fun i => tension_nonneg (mapW_law (h.labs i) f) hv
+    (lsupp.map h0 unif_law.nz f))
+
+set_option maxHeartbeats 800000 in
+theorem budget_progress [Nonempty B] (h : Ultra μ p) (w : Wgt B)
+    (hw : catalog μ p w) (f : B→C) (g : C→D) :
+    varOne (mapW w f) (mapW (bucket unif (g∘f) w) f) ^ 2 ≤
+      (budget μ p f-budget μ p (g∘f))*4 := by
+  classical
+  let q := mapW unif f
+  let Q (i : A) := mapW (p i) f
+  let R (i : A) := bucket q g (Q i)
+  have hu : IsLaw q := mapW_law unif_law f
+  have hQ (i) : IsLaw (Q i) := mapW_law (h.labs i) f
+  have he (i) : lsupp (Q i) q := lsupp.map
+    (p:=p i) (q:=unif) (fun i _ => by rw [unif_apply]; positivity) unif_law.nz f
+  have hp (i : A) :
+      varOne (Q i) (R i) ^ 2 ≤ tension (Q i) (R i) *4 :=
+    var_tension _ _ (hQ i) (bucket_law (hQ i) g hu.nz (he i))
+      (lsupp_bucket g (hQ i).nz hu.nz (he i))
+  have hn :
+      budget μ p f=avg μ (fun i => tension (Q i) (R i))+budget μ p (g∘f) := by
+    unfold budget
+    have hi := fun i : A => tension_stage (Q i) q (hQ i).nz hu.nz (he i) g
+    unfold Q q at hi
+    simp_rw [map_nested] at hi
+    rw [← avg_add]; exact avg_congr fun i _ => hi i
+  let Z (i : A) := varOne (Q i) (R i)
+  have hs : avg μ Z ^ 2 ≤ avg μ (fun i => Z i ^ 2) := by
+    have hh := avg_CS h.law.nz Z (fun _ => 1)
+    simp only [mul_one,one_pow,h.law.avg_const] at hh; exact hh
+  obtain ⟨s,hs',ht,rfl⟩ := hw
+  rw [bucket_m,map_mix]
+  have h' := (var_mix Q R hs').trans (avg_mono_left (fun i => var_nonneg ..) ht)
+  refine (pow_le_pow_left₀ (var_nonneg ..) h' 2).trans (hs.trans ?_)
+  have hz := avg_mono h.law.nz hp; rw [avg_mul] at hz
+  rw [hn]; exact hz.trans_eq (by ring)
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/ReindexedFourierSupport.lean

@@ -1,73 +1,73 @@
-import OAI.Combinatorics.HadwigerCounterexample.TesterFourierSupport
-
-namespace OAI
-
-/-! # Reindexed Fourier Support -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Finset Matrix Module LinearMap Submodule Function
-open scoped BigOperators
-variable {p : Shape} {n : ℕ} {I : Type} [Fintype I]
-
-namespace Move
-variable (c : Flit n) {j k : Vec (Fin n)}
-def jumpV : Vec (Fin n) ≃ Vec (Fin n) where
-  toFun := c.L.mulVec
-  invFun := c.R.mulVec
-  left_inv x := by change c.R*ᵥ(c.L *ᵥ x) = x; rw [mulVec_mulVec,c.RL,Matrix.one_mulVec]
-  right_inv x := by change c.L*ᵥ(c.R *ᵥ x) = x; rw [mulVec_mulVec,c.LR,Matrix.one_mulVec]
-def zreroute (p : Shape) (c : Flit n) (f : Wgt (Knobs p.g n)) :=
-  fun y => f ((vault p c).symm y)
-
-theorem zhat_jump (p : Shape) (c : Flit n) (f : Wgt (Knobs p.g n)) (y : Knobs p.g n)
-    (x : Vec (Fin n)) :
-    zhat p (zreroute p c f) y (c.dual.jumpV x)=zhat p f y x := by
-  classical
-  unfold zhat
-  rw [← avg_bij c.jumpV]
-  have he (z : Vec (Fin n)) : unif (c.jumpV z)=unif z := rfl
-  have hh (z) :
-      vectorPhase (c.dual.jumpV x) (c.jumpV z)= vectorPhase x z := by
-    unfold vectorPhase
-    change wsign (dotProduct (c.Rᵀ *ᵥ x) (c.L *ᵥ z))=_
-    rw [dotProduct_comm, dotProduct_transpose_mulVec,mulVec_mulVec,c.RL, Matrix.one_mulVec]
-  have ht (z) :
-      zreroute p c f (update y Block.Z (c.jumpV z))=f (update y Block.Z z) := by
-    unfold zreroute vault; simp only [doZ,Equiv.coe_fn_symm_mk,update_self]
-    change f (update (update y Block.Z _) _ (c.jumpV.symm (c.jumpV z)))=_
-    rw [Equiv.symm_apply_apply]; simp
-  simp_rw [he,hh,ht]
-
-theorem jump_in (c : Flit n) (S : Space (Vec (Fin n))) {z} (h : z ∈ S) :
-    c.dual.jumpV z∈c.plume S := by
-  rw [←colSp_pack S] at h
-  obtain ⟨u,h⟩ := h
-  refine ⟨u,?_⟩
-  change (c.Rᵀ*pack S)*ᵥu=c.dual.jumpV z
-  rw [← mulVec_mulVec,show pack S *ᵥ u=z from h]
-  rfl
-end Move
-
-namespace Template
-variable (v : Solo p)
-
-def rotor (v : Solo p) (c : Flit n) (m : Mixer p n) (x : Profile p n) :=
-  Move.zreroute p c (v.shanty m x)
-theorem rotor_budget (v : Solo p) (c : Flit n) (m : Mixer p n) (x : Profile p n)
-    (K s : ℕ) (hg : Odd p.g) (hm : unaryGood m K s) (hK : totalRank x≤K) (hx : 0<totalRank x)
-    (u : Knobs p.g n) (i : Vec (Fin n)) :
-    |zchar p (v.rotor c m x) i u|≤bp (-((p.J-s:ℕ):ℝ)) ∧
-    (i ∉ c.plume (v.scroll m x) → zchar p (v.rotor c m x) i u=0) := by
-  classical
-  obtain ⟨i,rfl⟩ := c.dual.jumpV.surjective i
-  unfold zchar rotor
-  rw [Move.zhat_jump,abs_mul,vectorPhase,wsign_abs,mul_one]
-  exact ⟨shanty_cap v m x K s hg hm hK hx u i,fun h =>
-    mul_eq_zero_of_left (shanty_outer v m x u hg i (fun he => h (Move.jump_in c _ he))) _⟩
-end Template
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.TesterFourierSupport
+
+namespace OAI
+
+/-! # Reindexed Fourier Support -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Finset Matrix Module LinearMap Submodule Function
+open scoped BigOperators
+variable {p : Shape} {n : ℕ} {I : Type} [Fintype I]
+
+namespace Move
+variable (c : Flit n) {j k : Vec (Fin n)}
+def jumpV : Vec (Fin n) ≃ Vec (Fin n) where
+  toFun := c.L.mulVec
+  invFun := c.R.mulVec
+  left_inv x := by change c.R*ᵥ(c.L *ᵥ x) = x; rw [mulVec_mulVec,c.RL,Matrix.one_mulVec]
+  right_inv x := by change c.L*ᵥ(c.R *ᵥ x) = x; rw [mulVec_mulVec,c.LR,Matrix.one_mulVec]
+def zreroute (p : Shape) (c : Flit n) (f : Wgt (Knobs p.g n)) :=
+  fun y => f ((vault p c).symm y)
+
+theorem zhat_jump (p : Shape) (c : Flit n) (f : Wgt (Knobs p.g n)) (y : Knobs p.g n)
+    (x : Vec (Fin n)) :
+    zhat p (zreroute p c f) y (c.dual.jumpV x)=zhat p f y x := by
+  classical
+  unfold zhat
+  rw [← avg_bij c.jumpV]
+  have he (z : Vec (Fin n)) : unif (c.jumpV z)=unif z := rfl
+  have hh (z) :
+      vectorPhase (c.dual.jumpV x) (c.jumpV z)= vectorPhase x z := by
+    unfold vectorPhase
+    change wsign (dotProduct (c.Rᵀ *ᵥ x) (c.L *ᵥ z))=_
+    rw [dotProduct_comm, dotProduct_transpose_mulVec,mulVec_mulVec,c.RL, Matrix.one_mulVec]
+  have ht (z) :
+      zreroute p c f (update y Block.Z (c.jumpV z))=f (update y Block.Z z) := by
+    unfold zreroute vault; simp only [doZ,Equiv.coe_fn_symm_mk,update_self]
+    change f (update (update y Block.Z _) _ (c.jumpV.symm (c.jumpV z)))=_
+    rw [Equiv.symm_apply_apply]; simp
+  simp_rw [he,hh,ht]
+
+theorem jump_in (c : Flit n) (S : Space (Vec (Fin n))) {z} (h : z ∈ S) :
+    c.dual.jumpV z∈c.plume S := by
+  rw [←colSp_pack S] at h
+  obtain ⟨u,h⟩ := h
+  refine ⟨u,?_⟩
+  change (c.Rᵀ*pack S)*ᵥu=c.dual.jumpV z
+  rw [← mulVec_mulVec,show pack S *ᵥ u=z from h]
+  rfl
+end Move
+
+namespace Template
+variable (v : Solo p)
+
+def rotor (v : Solo p) (c : Flit n) (m : Mixer p n) (x : Profile p n) :=
+  Move.zreroute p c (v.shanty m x)
+theorem rotor_budget (v : Solo p) (c : Flit n) (m : Mixer p n) (x : Profile p n)
+    (K s : ℕ) (hg : Odd p.g) (hm : unaryGood m K s) (hK : totalRank x≤K) (hx : 0<totalRank x)
+    (u : Knobs p.g n) (i : Vec (Fin n)) :
+    |zchar p (v.rotor c m x) i u|≤bp (-((p.J-s:ℕ):ℝ)) ∧
+    (i ∉ c.plume (v.scroll m x) → zchar p (v.rotor c m x) i u=0) := by
+  classical
+  obtain ⟨i,rfl⟩ := c.dual.jumpV.surjective i
+  unfold zchar rotor
+  rw [Move.zhat_jump,abs_mul,vectorPhase,wsign_abs,mul_one]
+  exact ⟨shanty_cap v m x K s hg hm hK hx u i,fun h =>
+    mul_eq_zero_of_left (shanty_outer v m x u hg i (fun he => h (Move.jump_in c _ he))) _⟩
+end Template
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/RelationMismatchBounds.lean

@@ -1,129 +1,129 @@
-import OAI.Combinatorics.HadwigerCounterexample.FiniteDualSystems
-
-namespace OAI
-
-/-! # Relation Mismatch Bounds -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Filter Matrix Finset Function Submodule LinearMap
-open scoped BigOperators Topology
-open Template
-variable {p:Shape} {N n r K : ℕ}
-namespace StatusAnalysis
-namespace DualAnalysis
-open Club Guild
-variable {d e : Rates}
-    {u:Terrain p r} {s:Gazette p r d} {t:Gazette p r e}
-    {β η δ:ℝ}
-
-def seeking (p : Shape) (A : Stalls p) :=
-  ∀ i, (A i).card+902 < Fintype.card (Label p.b)
-theorem any_label (A : Finset (Label p.b)) (h : A.card<Fintype.card (Label p.b)) :
-    ∃ x,x∉A := by
-  by_contra! hh
-  have hf := card_le_card (show univ ⊆ A from fun _ _=>hh _)
-  rw [card_univ] at hf; exact h.not_ge hf
-
-theorem generic_apt (p:Shape) (hg:3≤p.g) (x:Appearance p) (hx:x.f=Flavor.full) :
-    x.apt := by obtain ⟨s,h1,h2,h3⟩:=generic_summary p hg x.l x.q 0; exact ⟨s,hx ▸ h1,h2⟩
-
-set_option maxHeartbeats 900000 in
-theorem plenitude (h:origami p r u δ) (hs:reports p r u s β δ) (ht:reports p r u t β δ)
-    (hg:3 ≤ p.g) (A B:Stalls p) (hk:seeking p A) (hl:seeking p B)
-    (hβ:0<β) (hz:0<η) (hη : playbook p K*η<1/2*β^2)
-    (hd:∀ i,d i≤K^2) (he:∀ i,e i≤K^2):
-    Guild.rich (stellar u s t η A B) := by
-  classical
-  intro i S hu y
-  have hh a (b:Finset (Label p.b)) (h : b.card+902<Fintype.card (Label p.b)):
-      ∃ z,z∉b∧z∉S a := by
-    obtain ⟨z,hz⟩:=any_label (b∪S a) ((card_union_le ..).trans_lt ((Nat.add_le_add_left
-      (hu a) _).trans_lt h))
-    exact ⟨z,fun ht=>hz (mem_union_left _ ht),fun ht=>hz (mem_union_right _ ht)⟩
-  obtain ⟨v,h1,h2⟩:= hh true (A i.1) (hk _)
-  obtain ⟨w,h3,h4⟩:= hh false (B i.2) (hl _)
-  let x : Zodiac p:= ⟨⟨0,by omega⟩,y.1,fun i=>if i then v else w,fun _=>Flavor.full⟩
-  have hh : x.common:= fun i=> generic_apt p hg _ rfl
-  obtain ⟨W,hA,hB,hC⟩:= sturdy_contact u s t h hs ht hβ x hh (fun _=>rfl) i y.2.1 y.2.2 hz
-    ((mul_le_mul_of_nonneg_right (booklet_cap p K _ _ (hd _) (he _)) hz.le).trans_lt hη)
-  refine ⟨(x,W),⟨⟨h1,h3,hA⟩,fun i=>?_⟩,?_⟩
-  · cases i; exact h4; exact h2
-  exact Prod.ext rfl (Prod.ext hB hC)
-
-structure RhymeSet (d : ℕ) where
-    bit : F
-    coal : Cell d
-    headBit : F
-    gamma : F
-
-def RhymeSet.read {k : ℕ} (s:RhymeSet k) (q:F) (x: Whole k) :=
-    s.bit*x.2+ dotProduct s.coal x.1.2+ (s.bit+s.headBit)*x.1.1+s.gamma*q
-
-def RhymeSet.soot {k : ℕ} (s:RhymeSet k) {p:Shape} (x:Appearance p) (y:Magazine p k) :=
-    s.read x.q y.2
-
-def leftChime (q:DualCoefficients d e) (i:Grid) : RhymeSet (d i.1) :=
-   ⟨q.left i.2,q.north i,q.hed i,0⟩
-def rightChime (q:DualCoefficients d e) (i:Grid) : RhymeSet (e i.2) :=
-   ⟨q.right i.1,q.south i,q.hed i,q.gam i⟩
-set_option maxHeartbeats 900000 in
-theorem dual_eq (q:DualCoefficients d e) (V : StatusSp d e) (hq:q.law V)
-    (i:Grid) (x:Suite d e i) (hx:x∈V i) :
-    (leftChime q i).read x.1 x.2.1=(rightChime q i).read x.1 x.2.2 := by
-  classical
-  specialize hq i x hx
-  rcases x with ⟨a,⟨⟨b,u⟩,s⟩,⟨c,v⟩,t⟩
-  let f:= q.hed i; let W:= dotProduct (q.north i) u
-  let Z:= dotProduct (q.south i) v
-  let g:=q.left i.2; let h:=q.right i.1; let G:=q.gam i*a
-  change G+f*(b+c)+(W+Z)=g*(b+s)+h*(c+t) at hq
-  change g*s+W+(g+f)*b+0*_ = h*t+Z+(h+f)*c+G
-  apply sub_eq_zero.mp
-  rw [ZModModule.sub_eq_add]
-  calc _
-      _=(G+f*(b+c)+(W+Z))+(g*(b+s)+h*(c+t)):=by ring
-      _=0:= by rw [hq,char_two]
-
-def charge (u:Terrain p r) (x: Zodiac p) (X:Gazette p r d) (Y:Gazette p r e)
-    (i:Grid) (a:RhymeSet (d i.1)) (b:RhymeSet (e i.2)) :=
-    pr (circlet u X Y x i) (fun y=>a.soot (x.aspect true) y.1≠ b.soot (x.aspect false) y.2)
-
-def outstraps (a:Stalls p) (s:Straps (Label p.b)) (b:Bool):Stalls p:=
-   fun i=>a i∪s b
-
-set_option maxHeartbeats 900000 in
-theorem charge_counter (h:origami p r u δ) (hs:reports p r u s β δ) (ht:reports p r u t β δ)
-    (A B:Stalls p) (S : Straps (Label p.b)) (q:DualCoefficients d e)
-    (he:q.law (chapter (stellar u s t η A B) S)) (hη:0≤η)
-    (x: Zodiac p) (i:Grid) (hx:x.common) (hk:x.s true∉outstraps A S true i.1)
-    (hl:x.s false∉outstraps B S false i.2) :
-    charge u x s t i (leftChime q i) (rightChime q i)≤ num (Touch p d e i)*η := by
-  classical
-  let W:=circlet u s t x i
-  obtain ⟨hm,hn⟩:=circlet_state u s t h hs ht x hx i
-  let P:=fun y : Touch p d e i=> (leftChime q i).soot (x.aspect true) y.1≠
-    (rightChime q i).soot (x.aspect false) y.2
-  have hh (y): W y*ind (P y)≤η := by
-    by_cases hp : P y
-    · rw [ind_one hp,mul_one]
-      by_contra! hy
-      let C:=stellar u s t η A B
-      let v : Scriptum p d e i := (x,y)
-      have heq : (x.aspect true).fitsink y.1∧ (x.aspect false).fitsink y.2 := not_not.mp
-        (fun h=> (hη.trans_lt hy).ne' (hn y h))
-      have ht : (C i).zone S v :=
-        ⟨⟨fun h=>hk (mem_union_left _ h),fun h=>hl (mem_union_left _ h),hx,heq.1,heq.2,hy.le⟩,
-          fun i=>by cases i; exact fun h=>hl (mem_union_right _ h); exact fun h=>hk (mem_union_right _ h)⟩
-      exact hp (dual_eq q (chapter C S) he i ((C i).writes v) ((C i).band_write S ht))
-    rw [ind_zero hp,mul_zero]; exact hη
-  change pr W P≤ _
-  exact (Finset.sum_le_sum fun i _=> hh i).trans_eq (by simp [num])
-
-end DualAnalysis
-end StatusAnalysis
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.FiniteDualSystems
+
+namespace OAI
+
+/-! # Relation Mismatch Bounds -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Filter Matrix Finset Function Submodule LinearMap
+open scoped BigOperators Topology
+open Template
+variable {p:Shape} {N n r K : ℕ}
+namespace StatusAnalysis
+namespace DualAnalysis
+open Club Guild
+variable {d e : Rates}
+    {u:Terrain p r} {s:Gazette p r d} {t:Gazette p r e}
+    {β η δ:ℝ}
+
+def seeking (p : Shape) (A : Stalls p) :=
+  ∀ i, (A i).card+902 < Fintype.card (Label p.b)
+theorem any_label (A : Finset (Label p.b)) (h : A.card<Fintype.card (Label p.b)) :
+    ∃ x,x∉A := by
+  by_contra! hh
+  have hf := card_le_card (show univ ⊆ A from fun _ _=>hh _)
+  rw [card_univ] at hf; exact h.not_ge hf
+
+theorem generic_apt (p:Shape) (hg:3≤p.g) (x:Appearance p) (hx:x.f=Flavor.full) :
+    x.apt := by obtain ⟨s,h1,h2,h3⟩:=generic_summary p hg x.l x.q 0; exact ⟨s,hx ▸ h1,h2⟩
+
+set_option maxHeartbeats 900000 in
+theorem plenitude (h:origami p r u δ) (hs:reports p r u s β δ) (ht:reports p r u t β δ)
+    (hg:3 ≤ p.g) (A B:Stalls p) (hk:seeking p A) (hl:seeking p B)
+    (hβ:0<β) (hz:0<η) (hη : playbook p K*η<1/2*β^2)
+    (hd:∀ i,d i≤K^2) (he:∀ i,e i≤K^2):
+    Guild.rich (stellar u s t η A B) := by
+  classical
+  intro i S hu y
+  have hh a (b:Finset (Label p.b)) (h : b.card+902<Fintype.card (Label p.b)):
+      ∃ z,z∉b∧z∉S a := by
+    obtain ⟨z,hz⟩:=any_label (b∪S a) ((card_union_le ..).trans_lt ((Nat.add_le_add_left
+      (hu a) _).trans_lt h))
+    exact ⟨z,fun ht=>hz (mem_union_left _ ht),fun ht=>hz (mem_union_right _ ht)⟩
+  obtain ⟨v,h1,h2⟩:= hh true (A i.1) (hk _)
+  obtain ⟨w,h3,h4⟩:= hh false (B i.2) (hl _)
+  let x : Zodiac p:= ⟨⟨0,by omega⟩,y.1,fun i=>if i then v else w,fun _=>Flavor.full⟩
+  have hh : x.common:= fun i=> generic_apt p hg _ rfl
+  obtain ⟨W,hA,hB,hC⟩:= sturdy_contact u s t h hs ht hβ x hh (fun _=>rfl) i y.2.1 y.2.2 hz
+    ((mul_le_mul_of_nonneg_right (booklet_cap p K _ _ (hd _) (he _)) hz.le).trans_lt hη)
+  refine ⟨(x,W),⟨⟨h1,h3,hA⟩,fun i=>?_⟩,?_⟩
+  · cases i; exact h4; exact h2
+  exact Prod.ext rfl (Prod.ext hB hC)
+
+structure RhymeSet (d : ℕ) where
+    bit : F
+    coal : Cell d
+    headBit : F
+    gamma : F
+
+def RhymeSet.read {k : ℕ} (s:RhymeSet k) (q:F) (x: Whole k) :=
+    s.bit*x.2+ dotProduct s.coal x.1.2+ (s.bit+s.headBit)*x.1.1+s.gamma*q
+
+def RhymeSet.soot {k : ℕ} (s:RhymeSet k) {p:Shape} (x:Appearance p) (y:Magazine p k) :=
+    s.read x.q y.2
+
+def leftChime (q:DualCoefficients d e) (i:Grid) : RhymeSet (d i.1) :=
+   ⟨q.left i.2,q.north i,q.hed i,0⟩
+def rightChime (q:DualCoefficients d e) (i:Grid) : RhymeSet (e i.2) :=
+   ⟨q.right i.1,q.south i,q.hed i,q.gam i⟩
+set_option maxHeartbeats 900000 in
+theorem dual_eq (q:DualCoefficients d e) (V : StatusSp d e) (hq:q.law V)
+    (i:Grid) (x:Suite d e i) (hx:x∈V i) :
+    (leftChime q i).read x.1 x.2.1=(rightChime q i).read x.1 x.2.2 := by
+  classical
+  specialize hq i x hx
+  rcases x with ⟨a,⟨⟨b,u⟩,s⟩,⟨c,v⟩,t⟩
+  let f:= q.hed i; let W:= dotProduct (q.north i) u
+  let Z:= dotProduct (q.south i) v
+  let g:=q.left i.2; let h:=q.right i.1; let G:=q.gam i*a
+  change G+f*(b+c)+(W+Z)=g*(b+s)+h*(c+t) at hq
+  change g*s+W+(g+f)*b+0*_ = h*t+Z+(h+f)*c+G
+  apply sub_eq_zero.mp
+  rw [ZModModule.sub_eq_add]
+  calc _
+      _=(G+f*(b+c)+(W+Z))+(g*(b+s)+h*(c+t)):=by ring
+      _=0:= by rw [hq,char_two]
+
+def charge (u:Terrain p r) (x: Zodiac p) (X:Gazette p r d) (Y:Gazette p r e)
+    (i:Grid) (a:RhymeSet (d i.1)) (b:RhymeSet (e i.2)) :=
+    pr (circlet u X Y x i) (fun y=>a.soot (x.aspect true) y.1≠ b.soot (x.aspect false) y.2)
+
+def outstraps (a:Stalls p) (s:Straps (Label p.b)) (b:Bool):Stalls p:=
+   fun i=>a i∪s b
+
+set_option maxHeartbeats 900000 in
+theorem charge_counter (h:origami p r u δ) (hs:reports p r u s β δ) (ht:reports p r u t β δ)
+    (A B:Stalls p) (S : Straps (Label p.b)) (q:DualCoefficients d e)
+    (he:q.law (chapter (stellar u s t η A B) S)) (hη:0≤η)
+    (x: Zodiac p) (i:Grid) (hx:x.common) (hk:x.s true∉outstraps A S true i.1)
+    (hl:x.s false∉outstraps B S false i.2) :
+    charge u x s t i (leftChime q i) (rightChime q i)≤ num (Touch p d e i)*η := by
+  classical
+  let W:=circlet u s t x i
+  obtain ⟨hm,hn⟩:=circlet_state u s t h hs ht x hx i
+  let P:=fun y : Touch p d e i=> (leftChime q i).soot (x.aspect true) y.1≠
+    (rightChime q i).soot (x.aspect false) y.2
+  have hh (y): W y*ind (P y)≤η := by
+    by_cases hp : P y
+    · rw [ind_one hp,mul_one]
+      by_contra! hy
+      let C:=stellar u s t η A B
+      let v : Scriptum p d e i := (x,y)
+      have heq : (x.aspect true).fitsink y.1∧ (x.aspect false).fitsink y.2 := not_not.mp
+        (fun h=> (hη.trans_lt hy).ne' (hn y h))
+      have ht : (C i).zone S v :=
+        ⟨⟨fun h=>hk (mem_union_left _ h),fun h=>hl (mem_union_left _ h),hx,heq.1,heq.2,hy.le⟩,
+          fun i=>by cases i; exact fun h=>hl (mem_union_right _ h); exact fun h=>hk (mem_union_right _ h)⟩
+      exact hp (dual_eq q (chapter C S) he i ((C i).writes v) ((C i).band_write S ht))
+    rw [ind_zero hp,mul_zero]; exact hη
+  change pr W P≤ _
+  exact (Finset.sum_le_sum fun i _=> hh i).trans_eq (by simp [num])
+
+end DualAnalysis
+end StatusAnalysis
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/RelativeEntropy.lean

@@ -1,108 +1,108 @@
-import OAI.Combinatorics.HadwigerCounterexample.FiniteEntropy
-import OAI.Combinatorics.HadwigerCounterexample.WalshBounds
-
-namespace OAI
-
-/-! # Relative Entropy -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Finset Real
-open scoped BigOperators
-variable {A B C : Type} [Fintype A] [Fintype B] [Fintype C]
-
-def lsupp (p q : Wgt A) := ∀ x,p x ≠ 0 → q x≠0
-
-def tension (p q : Wgt A) := avg p (fun x => log (p x)-log (q x))
-def varOne (p q : Wgt A) := ∑ x, |p x-q x|
-
-theorem tension_of_ratio {p q : Wgt A} (h : lsupp p q) :
-    tension p q=avg p (fun x => log (p x/q x)) :=
-  avg_congr (fun i hi => (Real.log_div hi (h i hi)).symm)
-
-theorem tension_as_diff (p q : Wgt A) :
-    tension p q= negEnt p-avg p (fun x => log (q x)) := avg_sub p _ _
-
-theorem tension_mix {μ : Wgt A} {f : A→Wgt B} (q : Wgt B) :
-    avg μ (fun x => tension (f x) q) =
-      avg μ (fun x => tension (f x) (mixW μ f))+tension (mixW μ f) q := by
-  let u := mixW μ f
-  have h (x : A) : tension (f x) q=tension (f x) u+
-      avg (f x) (fun i => log (u i)-log (q i)) := by
-    simp only [tension_as_diff,avg_sub]
-    ring
-  simp_rw [h,avg_add,← mixW_avg]; rfl
-
-theorem tension_le_cap {p q : Wgt A} (hp : ∀ i,0 ≤ p i) (hq : ∀ i,0 ≤ q i)
-    (C : ℝ) (hc : 0<C) (h : ∀ i,p i≤ C*q i) :
-    tension p q≤tot p*log C := by
-  rw [←avg_const]
-  unfold tension avg
-  refine sum_le_sum fun i _ => ?_
-  rcases eq_or_lt_of_le (hp i) with h'|h'
-  · rw [←h']; simp
-  have hqi : q i ≠ 0 :=
-    (pos_of_mul_pos_right (h'.trans_le (h i)) hc.le).ne'
-  have hg : 0 < q i := lt_of_le_of_ne (hq i) (Ne.symm hqi)
-  refine mul_le_mul_of_nonneg_left ?_ h'.le
-  change log (p i) - log (q i) ≤ log C
-  rw [← Real.log_div h'.ne' hg.ne']
-  exact Real.log_le_log (by positivity) ((div_le_iff₀ hg).mpr (h i))
-
-private theorem tension_cell (a b : ℝ) (ha : 0≤a) (hb : 0 ≤ b) (h : a≠0→b≠0) :
-    (√a-√b)^2 ≤ a*(log a - log b)+ b - a := by
-  rcases eq_or_lt_of_le ha with h'|h'
-  · rw [← h']; simp only [sqrt_zero,zero_sub,neg_sq,zero_mul,zero_add,sub_zero]; rw [sq_sqrt hb]
-  have hb' := lt_of_le_of_ne hb (Ne.symm (h h'.ne'))
-  have hc : 0<√a := by positivity
-  have ht := Real.log_le_sub_one_of_pos (x:=√b/√a) (by positivity)
-  rw [Real.log_div (by positivity) (by positivity), Real.log_sqrt hb,Real.log_sqrt ha] at ht
-  have hh := mul_le_mul_of_nonneg_right ht ha
-  have he : √b/√a*a = √b*√a := by
-    field_simp; rw [sq_sqrt ha]
-  rw [sub_mul,sub_mul,he] at hh
-  nlinarith only [hh,sq_sqrt ha,sq_sqrt hb]
-
-set_option maxHeartbeats 600000 in
-theorem var_tension (p q : Wgt A) (hp : IsLaw p) (hq : IsLaw q) (h : lsupp p q) :
-    varOne p q ^ 2 ≤ tension p q * 4 := by
-  let a (i : A) := |√(p i)-√(q i)|
-  let b (i : A) := √(p i)+√(q i)
-  have ha : ∑ i, a i ^ 2 ≤ tension p q := by
-    have ht (x : A) :
-        a x ^2 ≤ p x * (log (p x)-log (q x))+q x-p x := by
-      unfold a; rw [sq_abs]; exact tension_cell _ _ (hp.nz _) (hq.nz _) (h _)
-    refine (sum_le_sum (fun i (_: i∈univ) => ht i)).trans_eq ?_
-    simp only [Finset.sum_sub_distrib,Finset.sum_add_distrib]
-    change _ +tot q-tot p=tension p q
-    rw [hp.total,hq.total,add_sub_cancel_right]
-    rfl
-  have hb : ∑ i,b i^2 ≤ 4 := by
-    have ht (x : A) :
-        b x ^ 2 ≤ 2*p x+2*q x := by
-      unfold b; nlinarith only [sq_sqrt (hp.nz x),sq_sqrt (hq.nz x),
-        sq_nonneg (√(p x)-√(q x))]
-    refine (sum_le_sum (fun i (_: i∈univ) => ht i)).trans_eq ?_
-    simp only [Finset.sum_add_distrib,← Finset.mul_sum]
-    change 2*tot p + 2*tot q = 4
-    rw [hp.total,hq.total]
-    norm_num
-  have h0 : 0≤tension p q := le_trans (sum_nonneg (fun i _ => sq_nonneg _)) ha
-  have he : varOne p q = ∑ i, a i * b i := by
-    unfold varOne
-    refine sum_congr rfl (fun i _ => ?_)
-    have hy :
-        (√(p i)-√(q i))*b i=p i-q i := by
-      unfold b; nlinarith only [sq_sqrt (hp.nz i),sq_sqrt (hq.nz i)]
-    rw [← hy,abs_mul,abs_of_nonneg (show 0≤b i from by unfold b; positivity)]
-  rw [he]
-  exact (Finset.sum_mul_sq_le_sq_mul_sq ..).trans
-    (mul_le_mul ha hb (sum_nonneg (fun i _ => sq_nonneg _)) h0)
-
-theorem tension_nonneg {p q : Wgt A} (hp : IsLaw p) (hq : IsLaw q) (h : lsupp p q) :
-    0 ≤ tension p q := by nlinarith only [var_tension p q hp hq h,sq_nonneg (varOne p q)]
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.FiniteEntropy
+import OAI.Combinatorics.HadwigerCounterexample.WalshBounds
+
+namespace OAI
+
+/-! # Relative Entropy -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Finset Real
+open scoped BigOperators
+variable {A B C : Type} [Fintype A] [Fintype B] [Fintype C]
+
+def lsupp (p q : Wgt A) := ∀ x,p x ≠ 0 → q x≠0
+
+def tension (p q : Wgt A) := avg p (fun x => log (p x)-log (q x))
+def varOne (p q : Wgt A) := ∑ x, |p x-q x|
+
+theorem tension_of_ratio {p q : Wgt A} (h : lsupp p q) :
+    tension p q=avg p (fun x => log (p x/q x)) :=
+  avg_congr (fun i hi => (Real.log_div hi (h i hi)).symm)
+
+theorem tension_as_diff (p q : Wgt A) :
+    tension p q= negEnt p-avg p (fun x => log (q x)) := avg_sub p _ _
+
+theorem tension_mix {μ : Wgt A} {f : A→Wgt B} (q : Wgt B) :
+    avg μ (fun x => tension (f x) q) =
+      avg μ (fun x => tension (f x) (mixW μ f))+tension (mixW μ f) q := by
+  let u := mixW μ f
+  have h (x : A) : tension (f x) q=tension (f x) u+
+      avg (f x) (fun i => log (u i)-log (q i)) := by
+    simp only [tension_as_diff,avg_sub]
+    ring
+  simp_rw [h,avg_add,← mixW_avg]; rfl
+
+theorem tension_le_cap {p q : Wgt A} (hp : ∀ i,0 ≤ p i) (hq : ∀ i,0 ≤ q i)
+    (C : ℝ) (hc : 0<C) (h : ∀ i,p i≤ C*q i) :
+    tension p q≤tot p*log C := by
+  rw [←avg_const]
+  unfold tension avg
+  refine sum_le_sum fun i _ => ?_
+  rcases eq_or_lt_of_le (hp i) with h'|h'
+  · rw [←h']; simp
+  have hqi : q i ≠ 0 :=
+    (pos_of_mul_pos_right (h'.trans_le (h i)) hc.le).ne'
+  have hg : 0 < q i := lt_of_le_of_ne (hq i) (Ne.symm hqi)
+  refine mul_le_mul_of_nonneg_left ?_ h'.le
+  change log (p i) - log (q i) ≤ log C
+  rw [← Real.log_div h'.ne' hg.ne']
+  exact Real.log_le_log (by positivity) ((div_le_iff₀ hg).mpr (h i))
+
+private theorem tension_cell (a b : ℝ) (ha : 0≤a) (hb : 0 ≤ b) (h : a≠0→b≠0) :
+    (√a-√b)^2 ≤ a*(log a - log b)+ b - a := by
+  rcases eq_or_lt_of_le ha with h'|h'
+  · rw [← h']; simp only [sqrt_zero,zero_sub,neg_sq,zero_mul,zero_add,sub_zero]; rw [sq_sqrt hb]
+  have hb' := lt_of_le_of_ne hb (Ne.symm (h h'.ne'))
+  have hc : 0<√a := by positivity
+  have ht := Real.log_le_sub_one_of_pos (x:=√b/√a) (by positivity)
+  rw [Real.log_div (by positivity) (by positivity), Real.log_sqrt hb,Real.log_sqrt ha] at ht
+  have hh := mul_le_mul_of_nonneg_right ht ha
+  have he : √b/√a*a = √b*√a := by
+    field_simp; rw [sq_sqrt ha]
+  rw [sub_mul,sub_mul,he] at hh
+  nlinarith only [hh,sq_sqrt ha,sq_sqrt hb]
+
+set_option maxHeartbeats 600000 in
+theorem var_tension (p q : Wgt A) (hp : IsLaw p) (hq : IsLaw q) (h : lsupp p q) :
+    varOne p q ^ 2 ≤ tension p q * 4 := by
+  let a (i : A) := |√(p i)-√(q i)|
+  let b (i : A) := √(p i)+√(q i)
+  have ha : ∑ i, a i ^ 2 ≤ tension p q := by
+    have ht (x : A) :
+        a x ^2 ≤ p x * (log (p x)-log (q x))+q x-p x := by
+      unfold a; rw [sq_abs]; exact tension_cell _ _ (hp.nz _) (hq.nz _) (h _)
+    refine (sum_le_sum (fun i (_: i∈univ) => ht i)).trans_eq ?_
+    simp only [Finset.sum_sub_distrib,Finset.sum_add_distrib]
+    change _ +tot q-tot p=tension p q
+    rw [hp.total,hq.total,add_sub_cancel_right]
+    rfl
+  have hb : ∑ i,b i^2 ≤ 4 := by
+    have ht (x : A) :
+        b x ^ 2 ≤ 2*p x+2*q x := by
+      unfold b; nlinarith only [sq_sqrt (hp.nz x),sq_sqrt (hq.nz x),
+        sq_nonneg (√(p x)-√(q x))]
+    refine (sum_le_sum (fun i (_: i∈univ) => ht i)).trans_eq ?_
+    simp only [Finset.sum_add_distrib,← Finset.mul_sum]
+    change 2*tot p + 2*tot q = 4
+    rw [hp.total,hq.total]
+    norm_num
+  have h0 : 0≤tension p q := le_trans (sum_nonneg (fun i _ => sq_nonneg _)) ha
+  have he : varOne p q = ∑ i, a i * b i := by
+    unfold varOne
+    refine sum_congr rfl (fun i _ => ?_)
+    have hy :
+        (√(p i)-√(q i))*b i=p i-q i := by
+      unfold b; nlinarith only [sq_sqrt (hp.nz i),sq_sqrt (hq.nz i)]
+    rw [← hy,abs_mul,abs_of_nonneg (show 0≤b i from by unfold b; positivity)]
+  rw [he]
+  exact (Finset.sum_mul_sq_le_sq_mul_sq ..).trans
+    (mul_le_mul ha hb (sum_nonneg (fun i _ => sq_nonneg _)) h0)
+
+theorem tension_nonneg {p q : Wgt A} (hp : IsLaw p) (hq : IsLaw q) (h : lsupp p q) :
+    0 ≤ tension p q := by nlinarith only [var_tension p q hp hq h,sq_nonneg (varOne p q)]
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/RelativeInjectionBounds.lean

@@ -1,110 +1,110 @@
-import OAI.Combinatorics.HadwigerCounterexample.TableInjectionTransfer
-
-namespace OAI
-
-/-! # Relative Injection Bounds -/
-
-noncomputable section
-namespace HadwigerCounterexample
-
-open Matrix LinearMap Module Submodule Function Finset Filter
-open scoped BigOperators Topology
-variable {p : Shape} {n N : ℕ}
-
-def fringe (N : ℕ) := bp (-0.01*N)
-def shine (N : ℕ) := bp (0.01*N)
-def edgeError (N : ℕ) := bp (-0.005*N)
-
-private theorem fire_budget (K : ℕ) (p : Shape) {l D : ℝ}
-    (hd : 0 ≤D) (hh : 2*K+l+200*(D+2 : ℝ) ≤ p.h) :
-    ∀ᶠ N : ℕ in atTop,
-      bp (D*N)*(fireBill p (N/100) K (shine N)/(pushCost (bp (-l)) K)^(N/100)) ≤ fringe N := by
-  have he := (tendsto_natCast_atTop_atTop (R:=ℝ)).eventually
-    (eventually_ge_atTop (1+p.h*(K:ℝ)))
-  filter_upwards [he,eventually_ge_atTop 100] with N hN hk
-  change (1+p.h*(K:ℝ))≤(N:ℝ) at hN
-  let k := N/100
-  have ht : N ≤ 200*k := by
-    have h1 : 1 ≤ N/100 := (Nat.le_div_iff_mul_le (by omega)).mpr (by simpa using hk)
-    have h := Nat.div_add_mod' N 100
-    unfold k; omega
-  have ht' : (N:ℝ)≤200*k := by exact_mod_cast ht
-  have h1 : (D+2)*N≤ (p.h-(2*K+(l:ℝ)))*k := by
-    have h := mul_le_mul_of_nonneg_left ht' (show 0≤D+2 by linarith)
-    have h' := mul_le_mul_of_nonneg_right hh (Nat.cast_nonneg k : 0≤(k:ℝ))
-    linarith only [h,h']
-  change bp _*(fireBill p k K (shine N)/_ ^ k)≤_
-  unfold fireBill pushCost shine fringe
-  rw [←bp_sub, ← bp_mul_nat, ← bp_one,←bp_add,←bp_add,←bp_sub,←bp_add]
-  apply bp_le
-  linarith only [h1,hN,(Nat.cast_nonneg N : 0≤(N:ℝ))]
-
-set_option maxHeartbeats 1000000 in
-theorem guard_grid (g K : ℕ) (D ε : ℝ) (hd : 0≤D) (he : 0<ε) :
-    ∀ᶠ h : ℕ in atTop,∀ p : Shape,p.g=g → p.h=h →
-    ∀ᶠ M : ℕ in atTop,∀ᶠ n : ℕ in atTop,let N:=M*n;
-    ∀ (P : UnitType p n N×UnitType p n N→Prop),
-    named P (bp (D*N)) → named (P ∘ Prod.swap) (bp (D*N)) →
-    ∀ w (b : Fpins p n N) (m : Mixer p n), (∀ x,planRank (b x)≤ K) →
-    IsLaw w → bySide p w m (shine N) → (∀ x,w x≠0 → ∀ i,frameLaw m (onSide x i)) →
-    pr (pairW w w) (fun x => P x ∧ ¬ secureAt p b x) ≤
-      ε*pr (pairW w w) P+edgeError N := by
-  let W := 8*num (Comp g×Bool)
-  obtain ⟨k,hk⟩ : ∃ k : ℕ,W*(3*bp (-(k:ℝ)))≤ ε := by
-    have hh : Tendsto (fun n : ℕ => W*(3*bp (-(n:ℝ)))) atTop (𝓝 0) := by
-      have hi := ((bp_nat_vanish (by norm_num : 0<(1:ℝ))).const_mul 3).const_mul W
-      simpa using hi
-    obtain ⟨n,hn⟩ := (hh.eventually (gt_mem_nhds he)).exists
-    exact ⟨n,hn.le⟩
-  let l := bp (-(k:ℝ))
-  filter_upwards [tendsto_natCast_atTop_atTop.eventually
-    (eventually_ge_atTop (2*K+(k:ℝ)+200*(D+2)))] with h hH p hg hp
-
-  have heq : (8*num (Place p):ℝ)*(3*l) ≤ ε := by
-    change (8*num (Comp p.g×Bool):ℝ)*(3*l) ≤ _
-    rwa [hg]
-  have hFire : ∀ᶠ N : ℕ in atTop,
-      bp (D*N)*(fireBill p (N/100) K (shine N)/(pushCost l K)^(N/100)) ≤ fringe N :=
-    fire_budget K p hd (hp.symm ▸ hH)
-  have hsmall : ∀ᶠ N : ℕ in atTop,
-      8*num (Place p)*(fringe N +fringe N)≤edgeError N := by
-    filter_upwards [bp_poly_dom_nat (by norm_num : 0<(0.005:ℝ)) (8*num (Place p)*2) 0] with N hN
-    unfold fringe edgeError
-    rw [←two_mul,←mul_assoc]
-    refine (mul_le_mul_of_nonneg_right (show _≤bp (0.005*N) from by simpa using hN.le)
-      (bp_pos _).le).trans_eq ?_
-    rw [←bp_add]; congr 1; ring
-  filter_upwards [eventually_grid hFire,eventually_grid hsmall,
-    columns_budget p (δ:=1) zero_lt_one 2 1 (by norm_num) zero_le_one,
-    eventually_grid (tendsto_natCast_atTop_atTop.eventually
-      (eventually_ge_atTop (10*((k:ℝ)+1))))] with M hM hT hS hY
-  filter_upwards [hM,hT,eventually_ge_atTop 1,hY] with n hM hT hn hY
-  dsimp only
-  intro P hP hQ w b m hb hw hW hx
-  let N := M*n
-  have hN : 2*num (Full p n)+1≤N := (hS n hn).trans_eq (one_mul _)
-  have hρ : rhUp (shine N) (2*fringe N)*2 * bp (num (Row p n)+(N/100:ℕ)-N)≤l := by
-    change 10*((k:ℝ)+1) ≤ N at hY
-    have hh : 100*((N/100:ℕ):ℝ)≤N := by exact_mod_cast (show 100*(N/100) ≤ N from Nat.mul_div_le _ _)
-    unfold rhUp shine fringe
-    rw [show 2*bp (-0.01*N)/2=bp (-0.01*N) from (by ring), ← bp_neg, ←bp_one,
-      ←bp_add,←bp_add,←bp_add]
-    apply bp_le
-    linarith only [hY,hN,hh,row_le p n]
-  have hl : 0<l:=bp_pos _
-  have hX := secure_bound hP hQ (bp_pos _ : 0<fringe N) (bp_pos _).le hl w b K (N/100) hb
-    hw m hW hx (by linarith only [hN]) hρ
-  let V := pr (pairW w w) P
-  have hv : 0≤V := pr_nonneg (pairW_law hw hw).nz
-  have hi := mul_le_mul_of_nonneg_right heq hv
-  refine hX.trans ?_
-  change (8*num (Place p))*(3*l*V+_ + bp (D*N)* _)≤ε*V+_
-  calc _ ≤ (8*num (Place p))*(3*l*V+fringe N + fringe N) :=
-      mul_le_mul_of_nonneg_left (add_le_add (show 3*l*V+fringe N ≤ _ from le_rfl) (show _ ≤ fringe N from hM)) (by unfold num; positivity)
-       _ ≤ _ := by linarith only [hi,hT]
-
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.TableInjectionTransfer
+
+namespace OAI
+
+/-! # Relative Injection Bounds -/
+
+noncomputable section
+namespace HadwigerCounterexample
+
+open Matrix LinearMap Module Submodule Function Finset Filter
+open scoped BigOperators Topology
+variable {p : Shape} {n N : ℕ}
+
+def fringe (N : ℕ) := bp (-0.01*N)
+def shine (N : ℕ) := bp (0.01*N)
+def edgeError (N : ℕ) := bp (-0.005*N)
+
+private theorem fire_budget (K : ℕ) (p : Shape) {l D : ℝ}
+    (hd : 0 ≤D) (hh : 2*K+l+200*(D+2 : ℝ) ≤ p.h) :
+    ∀ᶠ N : ℕ in atTop,
+      bp (D*N)*(fireBill p (N/100) K (shine N)/(pushCost (bp (-l)) K)^(N/100)) ≤ fringe N := by
+  have he := (tendsto_natCast_atTop_atTop (R:=ℝ)).eventually
+    (eventually_ge_atTop (1+p.h*(K:ℝ)))
+  filter_upwards [he,eventually_ge_atTop 100] with N hN hk
+  change (1+p.h*(K:ℝ))≤(N:ℝ) at hN
+  let k := N/100
+  have ht : N ≤ 200*k := by
+    have h1 : 1 ≤ N/100 := (Nat.le_div_iff_mul_le (by omega)).mpr (by simpa using hk)
+    have h := Nat.div_add_mod' N 100
+    unfold k; omega
+  have ht' : (N:ℝ)≤200*k := by exact_mod_cast ht
+  have h1 : (D+2)*N≤ (p.h-(2*K+(l:ℝ)))*k := by
+    have h := mul_le_mul_of_nonneg_left ht' (show 0≤D+2 by linarith)
+    have h' := mul_le_mul_of_nonneg_right hh (Nat.cast_nonneg k : 0≤(k:ℝ))
+    linarith only [h,h']
+  change bp _*(fireBill p k K (shine N)/_ ^ k)≤_
+  unfold fireBill pushCost shine fringe
+  rw [←bp_sub, ← bp_mul_nat, ← bp_one,←bp_add,←bp_add,←bp_sub,←bp_add]
+  apply bp_le
+  linarith only [h1,hN,(Nat.cast_nonneg N : 0≤(N:ℝ))]
+
+set_option maxHeartbeats 1000000 in
+theorem guard_grid (g K : ℕ) (D ε : ℝ) (hd : 0≤D) (he : 0<ε) :
+    ∀ᶠ h : ℕ in atTop,∀ p : Shape,p.g=g → p.h=h →
+    ∀ᶠ M : ℕ in atTop,∀ᶠ n : ℕ in atTop,let N:=M*n;
+    ∀ (P : UnitType p n N×UnitType p n N→Prop),
+    named P (bp (D*N)) → named (P ∘ Prod.swap) (bp (D*N)) →
+    ∀ w (b : Fpins p n N) (m : Mixer p n), (∀ x,planRank (b x)≤ K) →
+    IsLaw w → bySide p w m (shine N) → (∀ x,w x≠0 → ∀ i,frameLaw m (onSide x i)) →
+    pr (pairW w w) (fun x => P x ∧ ¬ secureAt p b x) ≤
+      ε*pr (pairW w w) P+edgeError N := by
+  let W := 8*num (Comp g×Bool)
+  obtain ⟨k,hk⟩ : ∃ k : ℕ,W*(3*bp (-(k:ℝ)))≤ ε := by
+    have hh : Tendsto (fun n : ℕ => W*(3*bp (-(n:ℝ)))) atTop (𝓝 0) := by
+      have hi := ((bp_nat_vanish (by norm_num : 0<(1:ℝ))).const_mul 3).const_mul W
+      simpa using hi
+    obtain ⟨n,hn⟩ := (hh.eventually (gt_mem_nhds he)).exists
+    exact ⟨n,hn.le⟩
+  let l := bp (-(k:ℝ))
+  filter_upwards [tendsto_natCast_atTop_atTop.eventually
+    (eventually_ge_atTop (2*K+(k:ℝ)+200*(D+2)))] with h hH p hg hp
+
+  have heq : (8*num (Place p):ℝ)*(3*l) ≤ ε := by
+    change (8*num (Comp p.g×Bool):ℝ)*(3*l) ≤ _
+    rwa [hg]
+  have hFire : ∀ᶠ N : ℕ in atTop,
+      bp (D*N)*(fireBill p (N/100) K (shine N)/(pushCost l K)^(N/100)) ≤ fringe N :=
+    fire_budget K p hd (hp.symm ▸ hH)
+  have hsmall : ∀ᶠ N : ℕ in atTop,
+      8*num (Place p)*(fringe N +fringe N)≤edgeError N := by
+    filter_upwards [bp_poly_dom_nat (by norm_num : 0<(0.005:ℝ)) (8*num (Place p)*2) 0] with N hN
+    unfold fringe edgeError
+    rw [←two_mul,←mul_assoc]
+    refine (mul_le_mul_of_nonneg_right (show _≤bp (0.005*N) from by simpa using hN.le)
+      (bp_pos _).le).trans_eq ?_
+    rw [←bp_add]; congr 1; ring
+  filter_upwards [eventually_grid hFire,eventually_grid hsmall,
+    columns_budget p (δ:=1) zero_lt_one 2 1 (by norm_num) zero_le_one,
+    eventually_grid (tendsto_natCast_atTop_atTop.eventually
+      (eventually_ge_atTop (10*((k:ℝ)+1))))] with M hM hT hS hY
+  filter_upwards [hM,hT,eventually_ge_atTop 1,hY] with n hM hT hn hY
+  dsimp only
+  intro P hP hQ w b m hb hw hW hx
+  let N := M*n
+  have hN : 2*num (Full p n)+1≤N := (hS n hn).trans_eq (one_mul _)
+  have hρ : rhUp (shine N) (2*fringe N)*2 * bp (num (Row p n)+(N/100:ℕ)-N)≤l := by
+    change 10*((k:ℝ)+1) ≤ N at hY
+    have hh : 100*((N/100:ℕ):ℝ)≤N := by exact_mod_cast (show 100*(N/100) ≤ N from Nat.mul_div_le _ _)
+    unfold rhUp shine fringe
+    rw [show 2*bp (-0.01*N)/2=bp (-0.01*N) from (by ring), ← bp_neg, ←bp_one,
+      ←bp_add,←bp_add,←bp_add]
+    apply bp_le
+    linarith only [hY,hN,hh,row_le p n]
+  have hl : 0<l:=bp_pos _
+  have hX := secure_bound hP hQ (bp_pos _ : 0<fringe N) (bp_pos _).le hl w b K (N/100) hb
+    hw m hW hx (by linarith only [hN]) hρ
+  let V := pr (pairW w w) P
+  have hv : 0≤V := pr_nonneg (pairW_law hw hw).nz
+  have hi := mul_le_mul_of_nonneg_right heq hv
+  refine hX.trans ?_
+  change (8*num (Place p))*(3*l*V+_ + bp (D*N)* _)≤ε*V+_
+  calc _ ≤ (8*num (Place p))*(3*l*V+fringe N + fringe N) :=
+      mul_le_mul_of_nonneg_left (add_le_add (show 3*l*V+fringe N ≤ _ from le_rfl) (show _ ≤ fringe N from hM)) (by unfold num; positivity)
+       _ ≤ _ := by linarith only [hi,hT]
+
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/RepeatedBatchLaws.lean

@@ -1,131 +1,131 @@
-import OAI.Combinatorics.HadwigerCounterexample.ConditionedBatchLaws
-
-namespace OAI
-
-/-! # Repeated Batch Laws -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Matrix Module LinearMap Submodule Finset Function
-open scoped BigOperators
-variable {I J G : Type} [Fintype I] [Fintype J] [Fintype G] [DecidableEq I]
-variable [DecidableEq J] [DecidableEq G] {p : Shape} {n N : ℕ}
-
-def tied (f : Route I G) (J : Type) : Route (J×I) G := f ∘ Prod.snd
-variable {f : Route I G}
-
-def pooled (A : J → NomQuery p n f) : NomQuery p n (tied f J) :=
-  fun g => Matrix.of (fun i j => A j.val.1 g i (⟨j.val.2,j.property⟩))
-
-omit [Fintype I] [Fintype J] [Fintype G] [DecidableEq I] [DecidableEq J] [DecidableEq G] in
-theorem peek_pooled (A B : J→NomQuery p n f) (x : Forum p n N G) (i : J) :
-    led i (peekR p (tied f J) (pooled A) (pooled B) x)=peekR p f (A i) (B i) x := by
-  apply Prod.ext <;> ext <;> rfl
-
-omit [Fintype I] [Fintype J] [Fintype G] [DecidableEq I] [DecidableEq J] [DecidableEq G] in
-theorem lane_pooled (A B : J→NomQuery p n f) (m : Mixer p n) (i : J) :
-    laneM (database m (pooled A) (pooled B)) i=database m (A i) (B i) := by
-  funext z; ext x y; rfl
-
-omit [Fintype G] in
-theorem pool_injective {A : J → NomQuery p n f} (h : ∀ i, Injective (pooled A i).mulVec) :
-    ∀ z i,Injective (A z i).mulVec := by
-  classical
-  intro z i
-  let e := condLane (tied f J) z i
-  have he : Injective e := by
-    intro a b h; exact Subtype.ext (congrArg (fun x : Port (tied f J) i => x.val.2) h)
-  have ho : A z i=pooled A i*embedMat e := by rw [mul_embedMat]; rfl
-  rw [ho]; exact inj_comp_mat _ _ (h i) (embedMat_inj he)
-
-theorem poUse (A B : J→NomQuery p n f) (m : Mixer p n)
-    (hN : 2*num (Full p n)<N)
-    (ha : ∀ i,Injective (pooled A i).mulVec) (hb : ∀ i, Injective (pooled B i).mulVec)
-    (F : Wgt (Rack (J×I) N)) :
-    avg (forumLaw m N) (fun x => F (peekR p (tied f J) (pooled A) (pooled B) x))=
-      avg (rackStation (database m (pooled A) (pooled B)) N) F := by
-  rw [← mapW_avg,law_peekR m hN ha hb]
-
-set_option maxHeartbeats 800000 in
-theorem pooled_batch (A B : J → NomQuery p n f) (m : Mixer p n)
-    (hN : 2*num (Full p n)<N)
-    (k : ℝ) (hk : ∀ i,num (Port (tied f J) i)≤k)
-    (hL : 2*k-N≤-1)
-    (ha : ∀ i, Injective (pooled A i).mulVec)
-    (hb : ∀ i, Injective (pooled B i).mulVec)
-    (F : J→ Wgt (Rack I N)) (hf : ∀ i x,|F i x|≤1) :
-    let w := forumLaw (G:=G) m N
-    |avg w (fun x => ∏ i, F i (peekR p f (A i) (B i) x)) -
-      ∏ i, avg w (fun x => F i (peekR p f (A i) (B i) x))|≤
-      2*netFact (tied f J)*twinkle (tied f J) k N := by
-  classical
-  let w := forumLaw m N (G:=G)
-  let Z := database m (pooled A) (pooled B)
-  have he i :
-      avg w (fun x => F i (peekR p f (A i) (B i) x))=
-        avg (rackStation (database m (A i) (B i)) N) (F i) := by
-    unfold w; rw [←mapW_avg,law_peekR m hN (pool_injective ha i) (pool_injective hb i)]
-  have hx :
-      avg w (fun x => ∏ i, F i (peekR p f (A i) (B i) x)) =
-        avg (rackStation Z N) (brightProd F) := by
-    rw [show avg (rackStation Z N) _ =_ from (poUse A B m hN ha hb (brightProd F)).symm]
-    refine avg_congr fun x _ => ?_
-    simp_rw [brightProd, peek_pooled]
-  dsimp only
-  change |avg w _ - ∏ i, avg w _| ≤ _
-  simp_rw [he]; rw [hx]
-  have hi := compare_lanes Z F hf k hk (fun i => by linarith only [hk i,hL])
-  simp_rw [Z,lane_pooled] at *
-  exact hi
-
-set_option maxHeartbeats 600000 in
-theorem pool_upper (A B : J → NomQuery p n f) (m : Mixer p n)
-    (hN : 2*num (Full p n)<N)
-    (ha : ∀ i, Injective (pooled A i).mulVec)
-    (hb : ∀ i, Injective (pooled B i).mulVec)
-    (hL : ∀ i,2*num (Port (tied f J) i)-N ≤ -1) (P : J→Rack I N → Prop) :
-    let w := forumLaw (G:=G) m N
-    pr w (fun x => ∀ i,P i (peekR p f (A i) (B i) x))≤
-      netFact (tied f J)* ∏ i, pr w (fun x => P i (peekR p f (A i) (B i) x)) := by
-  classical
-  let w := forumLaw (G:=G) m N
-  let S := database m (pooled A) (pooled B)
-  let q (x : Rack (J×I) N) := ∀ i,P i (led i x)
-  have h1 i :
-      pr w (fun x => P i (peekR p f (A i) (B i) x)) =
-        pr (rackStation (database m (A i) (B i)) N) (P i) := by
-    unfold w; rw [←mapW_pr,law_peekR m hN (pool_injective ha i) (pool_injective hb i)]
-  have ht :
-      pr w (fun x => ∀ i,P i (peekR p f (A i) (B i) x)) =
-        pr (rackStation S N) q := by
-    rw [show pr (rackStation S N) q= _ from
-      (poUse A B m hN ha hb (fun x => ind (q x))).symm]
-    refine avg_congr fun x _ => ?_
-    simp_rw [q,peek_pooled]
-  let M := netFact (tied f J)
-  let g (i : J) := bothPart (laneM S i) (N:=N)
-  have hg x (hh : bothPart S x ∧ q x) :
-      ∀ i,g i (led i x)∧ P i (led i x) := fun i => ⟨laneGram S _ hh.1 _,hh.2 i⟩
-  change pr w _ ≤ _
-  rw [ht, rackStation,← on_unif,pr_on]
-  have hx : pr unif (fun x : Rack (J×I) N => ∀ i,g i (led i x)∧ P i (led i x)) =
-      ∏ i,pr unif (fun x => g i x∧P i x) := by
-    change avg unif _=_
-    simp_rw [ind_all]
-    exact led_piece Finset.univ (fun i x => g i x∧P i x)
-  have hh0 := net_norm S N hL
-  refine (div_le_div₀ (pr_nonneg unif_law.nz)
-    (pr_mono unif_law.nz hg) (inv_pos_of_pos netFact_pos) hh0.1).trans ?_
-  rw [hx,div_eq_mul_inv,inv_inv,mul_comm]
-  apply mul_le_mul_of_nonneg_left _ netFact_pos.le
-  refine Finset.prod_le_prod₀ (fun i _ => pr_nonneg unif_law.nz) (fun i _ => ?_)
-  rw [pr_of_on unif_law.nz (g _),on_unif,h1]
-  have h0 (i) : pr unif (g i)≤1 := (pr_le_tot unif_law.nz).trans unif_law.total.le
-  apply le_trans (mul_le_mul_of_nonneg_right (h0 _) (pr_nonneg (unifOn_sub _).nz))
-  unfold g S; rw [lane_pooled,one_mul]; exact le_rfl
-
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.ConditionedBatchLaws
+
+namespace OAI
+
+/-! # Repeated Batch Laws -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Matrix Module LinearMap Submodule Finset Function
+open scoped BigOperators
+variable {I J G : Type} [Fintype I] [Fintype J] [Fintype G] [DecidableEq I]
+variable [DecidableEq J] [DecidableEq G] {p : Shape} {n N : ℕ}
+
+def tied (f : Route I G) (J : Type) : Route (J×I) G := f ∘ Prod.snd
+variable {f : Route I G}
+
+def pooled (A : J → NomQuery p n f) : NomQuery p n (tied f J) :=
+  fun g => Matrix.of (fun i j => A j.val.1 g i (⟨j.val.2,j.property⟩))
+
+omit [Fintype I] [Fintype J] [Fintype G] [DecidableEq I] [DecidableEq J] [DecidableEq G] in
+theorem peek_pooled (A B : J→NomQuery p n f) (x : Forum p n N G) (i : J) :
+    led i (peekR p (tied f J) (pooled A) (pooled B) x)=peekR p f (A i) (B i) x := by
+  apply Prod.ext <;> ext <;> rfl
+
+omit [Fintype I] [Fintype J] [Fintype G] [DecidableEq I] [DecidableEq J] [DecidableEq G] in
+theorem lane_pooled (A B : J→NomQuery p n f) (m : Mixer p n) (i : J) :
+    laneM (database m (pooled A) (pooled B)) i=database m (A i) (B i) := by
+  funext z; ext x y; rfl
+
+omit [Fintype G] in
+theorem pool_injective {A : J → NomQuery p n f} (h : ∀ i, Injective (pooled A i).mulVec) :
+    ∀ z i,Injective (A z i).mulVec := by
+  classical
+  intro z i
+  let e := condLane (tied f J) z i
+  have he : Injective e := by
+    intro a b h; exact Subtype.ext (congrArg (fun x : Port (tied f J) i => x.val.2) h)
+  have ho : A z i=pooled A i*embedMat e := by rw [mul_embedMat]; rfl
+  rw [ho]; exact inj_comp_mat _ _ (h i) (embedMat_inj he)
+
+theorem poUse (A B : J→NomQuery p n f) (m : Mixer p n)
+    (hN : 2*num (Full p n)<N)
+    (ha : ∀ i,Injective (pooled A i).mulVec) (hb : ∀ i, Injective (pooled B i).mulVec)
+    (F : Wgt (Rack (J×I) N)) :
+    avg (forumLaw m N) (fun x => F (peekR p (tied f J) (pooled A) (pooled B) x))=
+      avg (rackStation (database m (pooled A) (pooled B)) N) F := by
+  rw [← mapW_avg,law_peekR m hN ha hb]
+
+set_option maxHeartbeats 800000 in
+theorem pooled_batch (A B : J → NomQuery p n f) (m : Mixer p n)
+    (hN : 2*num (Full p n)<N)
+    (k : ℝ) (hk : ∀ i,num (Port (tied f J) i)≤k)
+    (hL : 2*k-N≤-1)
+    (ha : ∀ i, Injective (pooled A i).mulVec)
+    (hb : ∀ i, Injective (pooled B i).mulVec)
+    (F : J→ Wgt (Rack I N)) (hf : ∀ i x,|F i x|≤1) :
+    let w := forumLaw (G:=G) m N
+    |avg w (fun x => ∏ i, F i (peekR p f (A i) (B i) x)) -
+      ∏ i, avg w (fun x => F i (peekR p f (A i) (B i) x))|≤
+      2*netFact (tied f J)*twinkle (tied f J) k N := by
+  classical
+  let w := forumLaw m N (G:=G)
+  let Z := database m (pooled A) (pooled B)
+  have he i :
+      avg w (fun x => F i (peekR p f (A i) (B i) x))=
+        avg (rackStation (database m (A i) (B i)) N) (F i) := by
+    unfold w; rw [←mapW_avg,law_peekR m hN (pool_injective ha i) (pool_injective hb i)]
+  have hx :
+      avg w (fun x => ∏ i, F i (peekR p f (A i) (B i) x)) =
+        avg (rackStation Z N) (brightProd F) := by
+    rw [show avg (rackStation Z N) _ =_ from (poUse A B m hN ha hb (brightProd F)).symm]
+    refine avg_congr fun x _ => ?_
+    simp_rw [brightProd, peek_pooled]
+  dsimp only
+  change |avg w _ - ∏ i, avg w _| ≤ _
+  simp_rw [he]; rw [hx]
+  have hi := compare_lanes Z F hf k hk (fun i => by linarith only [hk i,hL])
+  simp_rw [Z,lane_pooled] at *
+  exact hi
+
+set_option maxHeartbeats 600000 in
+theorem pool_upper (A B : J → NomQuery p n f) (m : Mixer p n)
+    (hN : 2*num (Full p n)<N)
+    (ha : ∀ i, Injective (pooled A i).mulVec)
+    (hb : ∀ i, Injective (pooled B i).mulVec)
+    (hL : ∀ i,2*num (Port (tied f J) i)-N ≤ -1) (P : J→Rack I N → Prop) :
+    let w := forumLaw (G:=G) m N
+    pr w (fun x => ∀ i,P i (peekR p f (A i) (B i) x))≤
+      netFact (tied f J)* ∏ i, pr w (fun x => P i (peekR p f (A i) (B i) x)) := by
+  classical
+  let w := forumLaw (G:=G) m N
+  let S := database m (pooled A) (pooled B)
+  let q (x : Rack (J×I) N) := ∀ i,P i (led i x)
+  have h1 i :
+      pr w (fun x => P i (peekR p f (A i) (B i) x)) =
+        pr (rackStation (database m (A i) (B i)) N) (P i) := by
+    unfold w; rw [←mapW_pr,law_peekR m hN (pool_injective ha i) (pool_injective hb i)]
+  have ht :
+      pr w (fun x => ∀ i,P i (peekR p f (A i) (B i) x)) =
+        pr (rackStation S N) q := by
+    rw [show pr (rackStation S N) q= _ from
+      (poUse A B m hN ha hb (fun x => ind (q x))).symm]
+    refine avg_congr fun x _ => ?_
+    simp_rw [q,peek_pooled]
+  let M := netFact (tied f J)
+  let g (i : J) := bothPart (laneM S i) (N:=N)
+  have hg x (hh : bothPart S x ∧ q x) :
+      ∀ i,g i (led i x)∧ P i (led i x) := fun i => ⟨laneGram S _ hh.1 _,hh.2 i⟩
+  change pr w _ ≤ _
+  rw [ht, rackStation,← on_unif,pr_on]
+  have hx : pr unif (fun x : Rack (J×I) N => ∀ i,g i (led i x)∧ P i (led i x)) =
+      ∏ i,pr unif (fun x => g i x∧P i x) := by
+    change avg unif _=_
+    simp_rw [ind_all]
+    exact led_piece Finset.univ (fun i x => g i x∧P i x)
+  have hh0 := net_norm S N hL
+  refine (div_le_div₀ (pr_nonneg unif_law.nz)
+    (pr_mono unif_law.nz hg) (inv_pos_of_pos netFact_pos) hh0.1).trans ?_
+  rw [hx,div_eq_mul_inv,inv_inv,mul_comm]
+  apply mul_le_mul_of_nonneg_left _ netFact_pos.le
+  refine Finset.prod_le_prod₀ (fun i _ => pr_nonneg unif_law.nz) (fun i _ => ?_)
+  rw [pr_of_on unif_law.nz (g _),on_unif,h1]
+  have h0 (i) : pr unif (g i)≤1 := (pr_le_tot unif_law.nz).trans unif_law.total.le
+  apply le_trans (mul_le_mul_of_nonneg_right (h0 _) (pr_nonneg (unifOn_sub _).nz))
+  unfold g S; rw [lane_pooled,one_mul]; exact le_rfl
+
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/RepeatedQueryBounds.lean

@@ -1,161 +1,161 @@
-import OAI.Combinatorics.HadwigerCounterexample.BatchCharacters
-
-namespace OAI
-
-/-! # Repeated Query Bounds -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Matrix Module LinearMap Submodule Function Finset
-open scoped BigOperators
-variable {I J G : Type} [Fintype I] [Fintype J] [Fintype G]
-variable [DecidableEq I] [DecidableEq J] [DecidableEq G]
-variable {N : ℕ}
-
-private theorem num_cross_peak (E : Rail (I×J))
-    (he : ∀ i∈E,i.1.1≠i.2.1) (t : ℕ) :
-    nbr (fun v : Vec E=> peak (ledgerM E v)=t) ≤ bp (peakExpense I J t) := by
-  classical
-  let Γ := fun M : Avenue I J => interDraw M ∧ peak M=t
-  have hh (v) : interDraw (ledgerM E v) := fun i j k => within_recorded E v _ _
-    (fun h => he _ h rfl)
-  rw [nbr_eq_card]
-  apply le_trans _ (price_peak (I:=I) (J:=J) t)
-  rw [nbr_eq_card]
-  let f (v : {v : Vec E//peak (ledgerM E v)=t}) : { M//Γ M} :=
-    ⟨ledgerM E v.val, hh _,v.property⟩
-  have h : Injective f := by
-    intro v w he
-    apply Subtype.ext
-    have h : ledgerM E v.val=ledgerM E w.val := congrArg Subtype.val he
-    rw [←inLedger E v.val,h,inLedger]
-  exact_mod_cast Fintype.card_le_of_injective f h
-
-private theorem peak_sum (E : Rail (I×J))
-    (he : ∀ i∈E,i.1.1≠ i.2.1) (u : ℝ)
-    (h : peakExpense I J 1+u≤0) :
-    ∑ v : Vec E,bp (u*peak (ledgerM E v))≤num (I×J)+1 := by
-  classical
-  let T := Fintype.card (I×J)
-  let f (v : Vec E) : Fin (T+1) :=
-     ⟨peak (ledgerM E v), Nat.lt_succ_of_le (peak_le _)⟩
-  have hg : ∑ v : Vec E,bp (u*peak (ledgerM E v))=
-      ∑ i : Fin (T+1),bp (u*i.val) * nbr (fun v : Vec E => peak (ledgerM E v)=i.val) := by
-    unfold nbr tot; simp only [Finset.mul_sum]; rw [Finset.sum_comm]
-    refine Finset.sum_congr rfl fun v _ => ?_
-    rw [Finset.sum_eq_single (f v)]
-    · simp only [f,ind_true,mul_one]
-    · intro i _ hi; rw [ind_zero (show peak _≠i.val from
-        fun h => hi (Fin.ext h.symm)),mul_zero]
-    simp
-  have hi (i : Fin (T+1)) :
-      bp (u*i.val)*nbr (fun v : Vec E=>peak (ledgerM E v)=i.val) ≤ 1 := by
-    refine (mul_le_mul_of_nonneg_left (num_cross_peak E he i.val) (bp_pos _).le).trans ?_
-    rw [←bp_add,←bp_zero]
-    apply bp_le
-    unfold peakExpense at *
-    have h1 := mul_nonpos_of_nonpos_of_nonneg h (Nat.cast_nonneg i.val : 0≤(i.val:ℝ))
-    norm_num at h1
-    linarith only [h1]
-  rw [hg]
-  exact (Finset.sum_le_sum fun i _ => hi i).trans_eq (by simp [num,T])
-
-set_option maxHeartbeats 800000 in
-theorem cross_flood (E : Rail (I×J)) (Z : Vec E)
-    (he : ∀ i∈E,i.1.1≠ i.2.1) (u : ℝ) (hu : 0≤u)
-    (P : I → Rack J N → Prop) (hp : ∀ i,bp (-u)≤pr unif (P i))
-    (hδ : peakExpense I J 1+(-(N:ℝ)/2+2*u) ≤0) :
-    pr unif (fun x => traced x E Z ∧ ∀ i,P i (led i x))≤
-      bp (-(E.card:ℝ)) * (num (I×J)+1) *∏ i,pr unif (P i) := by
-  classical
-  let H := ∏ i,pr unif (P i)
-  have hg : 0≤H := Finset.prod_nonneg fun _ _ => pr_nonneg unif_law.nz
-  let C : ℝ := -(N:ℝ)/2+2*u
-  let F (v : Vec E) :=
-    vectorPhase v Z*avg unif (fun x => phasedBy (ledgerM E v) x*phot P x)
-  have hh v : F v ≤ bp (C*peak (ledgerM E v))*H := by
-    refine (le_abs_self _).trans ?_
-    unfold F; rw [abs_mul,vectorPhase,wsign_abs,one_mul]
-    exact light_bound _ P u hu hp
-  have heq : pr unif (fun x => traced x E Z ∧ ∀ i,P i (led i x))=
-      avg unif F := by
-    unfold pr F
-    simp_rw [ind_and,ind_all,rail_expand,← avg_mul,← avg_mul']
-    rw [avg_avg]
-    refine avg_congr fun v _ => avg_congr fun x _ => ?_
-    unfold phot; ring
-  rw [heq]
-  refine (avg_mono unif_law.nz hh).trans ?_
-  let lamh := bp (-(E.card:ℝ))
-  have he' (x : Vec E) :
-      unif x=lamh := by rw [unif_apply,card_space,dim_vec,Fintype.card_coe, ← bp_neg]
-  simp only [avg,he',← Finset.mul_sum]
-  rw [← Finset.sum_mul,mul_assoc]
-  exact mul_le_mul_of_nonneg_left (mul_le_mul_of_nonneg_right (peak_sum E he _ hδ) hg)
-    (bp_pos _).le
-
-def cInside (g : Route (I×J) G) :=
-  (crowded g).filter (fun i => i.1.1=i.2.1)
-
-omit [Fintype G] in
-theorem inside_count (g : Route (I×J) G) :
-    (cInside g).card≤ Fintype.card I*Fintype.card J*Fintype.card J := by
-  classical
-  let f : I×J×J → (I×J)×(I×J) := fun x => ((x.1,x.2.1),(x.1,x.2.2))
-  have h : cInside g ⊆ Finset.univ.image f := by
-    rintro ⟨⟨x,i⟩,y,j⟩ hv
-    obtain rfl : x=y := (mem_filter.mp hv).2
-    exact mem_image.mpr ⟨(x,i,j),mem_univ _,rfl⟩
-  exact (card_le_card h).trans (card_image_le.trans_eq (by simp [mul_assoc]))
-
-set_option maxHeartbeats 800000 in
-theorem many_frames (g : Route (I×J) G) (Z : GeoM g) (hN : ∀ i,2*num (Port g i)-N≤ -1)
-    (u : ℝ) (hu : 0≤u) (P : I→Rack J N→Prop) (hp : ∀ i,bp (-u) ≤ pr unif (P i))
-    (hd : peakExpense I J 1+ (-(N:ℝ)/2+2*u) ≤0) :
-    pr (rackStation Z N) (fun x => ∀ i,P i (led i x))≤
-      (4:ℝ)^Fintype.card G * bp (num I * num J * num J) * (num (I×J)+1) *
-        ∏ i:I,pr unif (P i) := by
-  classical
-  let E := crowded g
-  let Y := cInside g
-  let R := E\Y
-  have hn := (net_norm Z N hN).1
-  let Z' := directions g Z
-  let w (x : R) := Z' ⟨x.val,sdiff_subset x.property⟩
-  have hl (x : Rack (I×J) N) (h : gramPart Z x) :
-      traced x R w := by
-    have he := (match_crowd x g Z).mpr h
-    funext i
-    exact congr_fun he (⟨i.val,sdiff_subset i.property⟩ : ↑E)
-  have he i (h : i∈R) : i.1.1≠ i.2.1 := by
-    intro hx
-    obtain ⟨h1,h2⟩ := Finset.mem_sdiff.mp h
-    exact h2 (Finset.mem_filter.mpr ⟨h1,hx⟩)
-  let Q := fun x => ∀ i, P i (led i x)
-  let H := ∏ i,pr unif (P i)
-  have h0 := netFact_pos (f:=g)
-  unfold rackStation
-  rw [← on_unif, pr_on]
-  have hh : pr unif (fun x => bothPart (N:=N) Z x ∧ Q x) ≤
-      pr unif (fun x => traced x R w ∧ Q x) :=
-    pr_mono unif_law.nz (fun x h => ⟨hl x ((both_test ..).mp h.1).1,h.2⟩)
-  have hf := cross_flood R w he u hu P hp hd
-  refine le_trans (div_le_div₀ ((pr_nonneg unif_law.nz).trans hf)
-    (hh.trans hf) (inv_pos_of_pos h0) hn) ?_
-  let K : ℝ := num (I×J)+1
-  have hk : 0 ≤ K := by unfold K num; positivity
-  change bp (- (R.card:ℝ)) * K * H / (netFact g)⁻¹ ≤ (4:ℝ)^_ * _ * K * H
-  have hY : Y ⊆ E := Finset.filter_subset ..
-  have hy : (R.card:ℝ)+(Y.card:ℝ) = netSize g := by
-    rw [← rail_count]; exact_mod_cast Finset.card_sdiff_add_card_eq_card hY
-  have hY' : (Y.card:ℝ) ≤ num I * num J * num J := by exact_mod_cast inside_count g
-  unfold netFact
-  have hg : 0 ≤ H := Finset.prod_nonneg fun i _ => pr_nonneg unif_law.nz
-  calc _ = (4:ℝ)^Fintype.card G * bp (netSize g- (R.card:ℝ))*K*H := by
-            rw [div_eq_mul_inv,inv_inv,bp_sub,bp_neg]; ring
-       _ ≤ _ := by gcongr; linarith
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.BatchCharacters
+
+namespace OAI
+
+/-! # Repeated Query Bounds -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Matrix Module LinearMap Submodule Function Finset
+open scoped BigOperators
+variable {I J G : Type} [Fintype I] [Fintype J] [Fintype G]
+variable [DecidableEq I] [DecidableEq J] [DecidableEq G]
+variable {N : ℕ}
+
+private theorem num_cross_peak (E : Rail (I×J))
+    (he : ∀ i∈E,i.1.1≠i.2.1) (t : ℕ) :
+    nbr (fun v : Vec E=> peak (ledgerM E v)=t) ≤ bp (peakExpense I J t) := by
+  classical
+  let Γ := fun M : Avenue I J => interDraw M ∧ peak M=t
+  have hh (v) : interDraw (ledgerM E v) := fun i j k => within_recorded E v _ _
+    (fun h => he _ h rfl)
+  rw [nbr_eq_card]
+  apply le_trans _ (price_peak (I:=I) (J:=J) t)
+  rw [nbr_eq_card]
+  let f (v : {v : Vec E//peak (ledgerM E v)=t}) : { M//Γ M} :=
+    ⟨ledgerM E v.val, hh _,v.property⟩
+  have h : Injective f := by
+    intro v w he
+    apply Subtype.ext
+    have h : ledgerM E v.val=ledgerM E w.val := congrArg Subtype.val he
+    rw [←inLedger E v.val,h,inLedger]
+  exact_mod_cast Fintype.card_le_of_injective f h
+
+private theorem peak_sum (E : Rail (I×J))
+    (he : ∀ i∈E,i.1.1≠ i.2.1) (u : ℝ)
+    (h : peakExpense I J 1+u≤0) :
+    ∑ v : Vec E,bp (u*peak (ledgerM E v))≤num (I×J)+1 := by
+  classical
+  let T := Fintype.card (I×J)
+  let f (v : Vec E) : Fin (T+1) :=
+     ⟨peak (ledgerM E v), Nat.lt_succ_of_le (peak_le _)⟩
+  have hg : ∑ v : Vec E,bp (u*peak (ledgerM E v))=
+      ∑ i : Fin (T+1),bp (u*i.val) * nbr (fun v : Vec E => peak (ledgerM E v)=i.val) := by
+    unfold nbr tot; simp only [Finset.mul_sum]; rw [Finset.sum_comm]
+    refine Finset.sum_congr rfl fun v _ => ?_
+    rw [Finset.sum_eq_single (f v)]
+    · simp only [f,ind_true,mul_one]
+    · intro i _ hi; rw [ind_zero (show peak _≠i.val from
+        fun h => hi (Fin.ext h.symm)),mul_zero]
+    simp
+  have hi (i : Fin (T+1)) :
+      bp (u*i.val)*nbr (fun v : Vec E=>peak (ledgerM E v)=i.val) ≤ 1 := by
+    refine (mul_le_mul_of_nonneg_left (num_cross_peak E he i.val) (bp_pos _).le).trans ?_
+    rw [←bp_add,←bp_zero]
+    apply bp_le
+    unfold peakExpense at *
+    have h1 := mul_nonpos_of_nonpos_of_nonneg h (Nat.cast_nonneg i.val : 0≤(i.val:ℝ))
+    norm_num at h1
+    linarith only [h1]
+  rw [hg]
+  exact (Finset.sum_le_sum fun i _ => hi i).trans_eq (by simp [num,T])
+
+set_option maxHeartbeats 800000 in
+theorem cross_flood (E : Rail (I×J)) (Z : Vec E)
+    (he : ∀ i∈E,i.1.1≠ i.2.1) (u : ℝ) (hu : 0≤u)
+    (P : I → Rack J N → Prop) (hp : ∀ i,bp (-u)≤pr unif (P i))
+    (hδ : peakExpense I J 1+(-(N:ℝ)/2+2*u) ≤0) :
+    pr unif (fun x => traced x E Z ∧ ∀ i,P i (led i x))≤
+      bp (-(E.card:ℝ)) * (num (I×J)+1) *∏ i,pr unif (P i) := by
+  classical
+  let H := ∏ i,pr unif (P i)
+  have hg : 0≤H := Finset.prod_nonneg fun _ _ => pr_nonneg unif_law.nz
+  let C : ℝ := -(N:ℝ)/2+2*u
+  let F (v : Vec E) :=
+    vectorPhase v Z*avg unif (fun x => phasedBy (ledgerM E v) x*phot P x)
+  have hh v : F v ≤ bp (C*peak (ledgerM E v))*H := by
+    refine (le_abs_self _).trans ?_
+    unfold F; rw [abs_mul,vectorPhase,wsign_abs,one_mul]
+    exact light_bound _ P u hu hp
+  have heq : pr unif (fun x => traced x E Z ∧ ∀ i,P i (led i x))=
+      avg unif F := by
+    unfold pr F
+    simp_rw [ind_and,ind_all,rail_expand,← avg_mul,← avg_mul']
+    rw [avg_avg]
+    refine avg_congr fun v _ => avg_congr fun x _ => ?_
+    unfold phot; ring
+  rw [heq]
+  refine (avg_mono unif_law.nz hh).trans ?_
+  let lamh := bp (-(E.card:ℝ))
+  have he' (x : Vec E) :
+      unif x=lamh := by rw [unif_apply,card_space,dim_vec,Fintype.card_coe, ← bp_neg]
+  simp only [avg,he',← Finset.mul_sum]
+  rw [← Finset.sum_mul,mul_assoc]
+  exact mul_le_mul_of_nonneg_left (mul_le_mul_of_nonneg_right (peak_sum E he _ hδ) hg)
+    (bp_pos _).le
+
+def cInside (g : Route (I×J) G) :=
+  (crowded g).filter (fun i => i.1.1=i.2.1)
+
+omit [Fintype G] in
+theorem inside_count (g : Route (I×J) G) :
+    (cInside g).card≤ Fintype.card I*Fintype.card J*Fintype.card J := by
+  classical
+  let f : I×J×J → (I×J)×(I×J) := fun x => ((x.1,x.2.1),(x.1,x.2.2))
+  have h : cInside g ⊆ Finset.univ.image f := by
+    rintro ⟨⟨x,i⟩,y,j⟩ hv
+    obtain rfl : x=y := (mem_filter.mp hv).2
+    exact mem_image.mpr ⟨(x,i,j),mem_univ _,rfl⟩
+  exact (card_le_card h).trans (card_image_le.trans_eq (by simp [mul_assoc]))
+
+set_option maxHeartbeats 800000 in
+theorem many_frames (g : Route (I×J) G) (Z : GeoM g) (hN : ∀ i,2*num (Port g i)-N≤ -1)
+    (u : ℝ) (hu : 0≤u) (P : I→Rack J N→Prop) (hp : ∀ i,bp (-u) ≤ pr unif (P i))
+    (hd : peakExpense I J 1+ (-(N:ℝ)/2+2*u) ≤0) :
+    pr (rackStation Z N) (fun x => ∀ i,P i (led i x))≤
+      (4:ℝ)^Fintype.card G * bp (num I * num J * num J) * (num (I×J)+1) *
+        ∏ i:I,pr unif (P i) := by
+  classical
+  let E := crowded g
+  let Y := cInside g
+  let R := E\Y
+  have hn := (net_norm Z N hN).1
+  let Z' := directions g Z
+  let w (x : R) := Z' ⟨x.val,sdiff_subset x.property⟩
+  have hl (x : Rack (I×J) N) (h : gramPart Z x) :
+      traced x R w := by
+    have he := (match_crowd x g Z).mpr h
+    funext i
+    exact congr_fun he (⟨i.val,sdiff_subset i.property⟩ : ↑E)
+  have he i (h : i∈R) : i.1.1≠ i.2.1 := by
+    intro hx
+    obtain ⟨h1,h2⟩ := Finset.mem_sdiff.mp h
+    exact h2 (Finset.mem_filter.mpr ⟨h1,hx⟩)
+  let Q := fun x => ∀ i, P i (led i x)
+  let H := ∏ i,pr unif (P i)
+  have h0 := netFact_pos (f:=g)
+  unfold rackStation
+  rw [← on_unif, pr_on]
+  have hh : pr unif (fun x => bothPart (N:=N) Z x ∧ Q x) ≤
+      pr unif (fun x => traced x R w ∧ Q x) :=
+    pr_mono unif_law.nz (fun x h => ⟨hl x ((both_test ..).mp h.1).1,h.2⟩)
+  have hf := cross_flood R w he u hu P hp hd
+  refine le_trans (div_le_div₀ ((pr_nonneg unif_law.nz).trans hf)
+    (hh.trans hf) (inv_pos_of_pos h0) hn) ?_
+  let K : ℝ := num (I×J)+1
+  have hk : 0 ≤ K := by unfold K num; positivity
+  change bp (- (R.card:ℝ)) * K * H / (netFact g)⁻¹ ≤ (4:ℝ)^_ * _ * K * H
+  have hY : Y ⊆ E := Finset.filter_subset ..
+  have hy : (R.card:ℝ)+(Y.card:ℝ) = netSize g := by
+    rw [← rail_count]; exact_mod_cast Finset.card_sdiff_add_card_eq_card hY
+  have hY' : (Y.card:ℝ) ≤ num I * num J * num J := by exact_mod_cast inside_count g
+  unfold netFact
+  have hg : 0 ≤ H := Finset.prod_nonneg fun i _ => pr_nonneg unif_law.nz
+  calc _ = (4:ℝ)^Fintype.card G * bp (netSize g- (R.card:ℝ))*K*H := by
+            rw [div_eq_mul_inv,inv_inv,bp_sub,bp_neg]; ring
+       _ ≤ _ := by gcongr; linarith
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/RepeatedQueryEnergy.lean

@@ -1,117 +1,117 @@
-import OAI.Combinatorics.HadwigerCounterexample.EmpiricalInformation
-
-namespace OAI
-
-/-! # Repeated Query Energy -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Finset Real
-open scoped BigOperators
-variable {A B C X J : Type} [Fintype A] [Fintype B] [Fintype X] [Fintype J]
-variable [DecidableEq J]
-
-omit [Fintype B] in
-theorem path_repeat {μ : Wgt A} {w : Wgt X} (f : A→ X→B) :
-    mixW μ (fun i => draws J (mapW w (f i))) =
-      mixW (draws J w) (fun x => mapW μ (fun i => f i ∘ x)) := by
-  classical
-  funext i
-  have h (j : A) :
-      draws J (mapW w (f j)) i=pr (draws J w) (fun x => f j ∘ x=i) := by
-    simp_rw [funext_iff]
-    exact Eq.symm (prodW_pr _ (fun l y => f j y=i l))
-  simp_rw [mixW,h]
-  exact avg_avg ..
-
-theorem path_sub (w : Wgt X) (p : X→Prop) (f : X → Wgt A)
-    (hw : SubLaw w) (hf : ∀ i,IsLaw (f i)) :
-    SubLaw (mixW (subW w p) f) ∧ tot (mixW (subW w p) f)=pr w p := by
-  have hh : tot (mixW (subW w p) f)=pr w p := by
-    rw [mixW_tot]; simp_rw [(hf _).total,avg_const,mul_one,subW_tot]
-  exact ⟨⟨fun i => avg_nonneg (subLaw_sub hw p).nz (fun j => (hf j).nz i),
-    hh ▸ (pr_le_tot hw.nz).trans hw.total⟩,hh⟩
-
-omit [Fintype A] in
-theorem path_patch (w : Wgt X) (p : X→Prop) (f : X → Wgt A) :
-    ∀ i,mixW w f i=mixW (subW w p) f i+mixW (subW w (fun x=>¬ p x)) f i := by
-  intro i
-  unfold mixW subW avg
-  rw [←Finset.sum_add_distrib]; simp_rw [ind_not]
-  exact sum_congr rfl fun j _ => by ring
-
-set_option maxHeartbeats 1000000 in
-theorem path_energy (μ : Wgt A) (w : Wgt X) (q : Wgt B)
-    (f : A → X→B) (hμ : IsLaw μ) (hw : IsLaw w) (hq : IsLaw q)
-    (h : ∀ i j,q (f i j)≠0)
-    (u : ℝ) (hu : 0≤u) (hp : ∀ i,q i ≠0 → bp (-u)≤q i)
-    (l : ℕ) (P : (Fin l→X)→ Prop) (r : ℝ)
-    (hr : pr (draws (Fin l) w) (fun x => ¬ P x)≤r)
-    (C : ℝ) (hc : 0≤C)
-    (hP : ∀ x,P x→ ∀ y,mapW μ (fun i => f i ∘ x) y ≤ bp C * draws (Fin l) q y) :
-    (l:ℝ)* avg μ (fun i => tension (mapW w (f i)) q) ≤
-      num B*log (↑l+1)+(C+r*u*l+1)*log 2 := by
-  classical
-  let F (i : A) := mapW w (f i)
-  let W := draws (Fin l) w
-  let Q := draws (Fin l) q
-  let k (x : Fin l → X) := mapW μ (fun i => f i ∘ x)
-  let g := mixW (subW W P) k
-  let b := mixW (subW W (fun x => ¬ P x)) k
-  let V := mixW μ (fun i => draws (Fin l) (F i))
-  have h0 : ∀ i, lsupp (F i) q := by
-    intro i j hj; obtain ⟨t,ht,rfl⟩ := lsupp_witness hj
-    exact h _ _
-  have hF : ∀ i,IsLaw (F i) := fun i => mapW_law hw (f i)
-  have hV : IsLaw V := mixW_law hμ (fun i => draws_law (hF i))
-  have hQ : IsLaw Q := draws_law hq
-  have hW : IsLaw W := draws_law hw
-  have hk : ∀ i,IsLaw (k i) := fun i => mapW_law hμ _
-  have h1 := traj_charge (l:=l) μ F q hμ hF h0
-  have h2 : ∀ i,V i=g i+b i := by unfold V F; rw [path_repeat]; exact path_patch W P k
-  have hg := path_sub W P k hW.sub hk
-  have hb := path_sub W (fun x => ¬ P x) k hW.sub hk
-  have h2L : 0 ≤ log (2:ℝ) := (Real.log_pos (by norm_num)).le
-  have h3 : tension g Q ≤ C*log 2 := by
-    have hz i : g i ≤ bp C*Q i := by
-      let c := bp C*Q i
-      have hc : 0≤c := mul_nonneg (bp_pos _).le (hQ.nz _)
-      have he (j) : ind (P j)*k j i ≤ c := by
-        by_cases h : P j
-        · rw [ind_one h,one_mul]; exact hP j h i
-        rw [ind_zero h,zero_mul]; exact hc
-      refine le_trans ?_ (hW.avg_le he)
-      simp only [g,mixW,subW,avg,mul_assoc]; rfl
-    refine (tension_le_cap hg.1.nz hQ.nz _ (bp_pos _) hz).trans ?_
-    rw [log_bp]
-    exact (mul_le_mul_of_nonneg_right hg.1.total
-      (mul_nonneg hc h2L)).trans_eq (one_mul _)
-  have h4 : tension b Q ≤ r*(u*l*log 2) := by
-    have hz (i : Fin l → B) : b i ≤ bp (u*l)*Q i := by
-      by_cases he : Q i=0
-      · have ht (j) : k j i=0 := by
-          by_contra h
-          obtain ⟨z,hz,rfl⟩ := lsupp_witness h
-          have ht : Q (f z ∘ j) ≠ 0 := by
-            change ∏ i:Fin l,q (f z (j i)) ≠0
-            rw [Finset.prod_ne_zero_iff]; exact fun i _ => ‹∀ i j,q (f i j)≠0› _ _
-          exact ht he
-        unfold b mixW; simp_rw [ht]; rw [he,avg_zero,mul_zero]
-      have hq := traj_cap q hq u hp i he
-      refine (hb.1.weight_le_one i).trans ?_
-      exact (le_of_eq (by rw [←bp_add,show u*l+ -u*l = 0 by ring,bp_zero])).trans
-        (mul_le_mul_of_nonneg_left hq (bp_pos _).le)
-    refine (tension_le_cap hb.1.nz hQ.nz _ (bp_pos _) hz).trans ?_
-    rw [log_bp]
-    exact mul_le_mul_of_nonneg_right (hb.2.le.trans hr)
-      (by apply mul_nonneg (by positivity) h2L)
-  apply h1.trans
-  refine add_le_add_right ?_ _
-  have h5 := tension_add_le V g b Q h2 hg.1.nz hb.1.nz
-  rw [hV.total] at h5
-  linarith only [h5,h4,h3]
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.EmpiricalInformation
+
+namespace OAI
+
+/-! # Repeated Query Energy -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Finset Real
+open scoped BigOperators
+variable {A B C X J : Type} [Fintype A] [Fintype B] [Fintype X] [Fintype J]
+variable [DecidableEq J]
+
+omit [Fintype B] in
+theorem path_repeat {μ : Wgt A} {w : Wgt X} (f : A→ X→B) :
+    mixW μ (fun i => draws J (mapW w (f i))) =
+      mixW (draws J w) (fun x => mapW μ (fun i => f i ∘ x)) := by
+  classical
+  funext i
+  have h (j : A) :
+      draws J (mapW w (f j)) i=pr (draws J w) (fun x => f j ∘ x=i) := by
+    simp_rw [funext_iff]
+    exact Eq.symm (prodW_pr _ (fun l y => f j y=i l))
+  simp_rw [mixW,h]
+  exact avg_avg ..
+
+theorem path_sub (w : Wgt X) (p : X→Prop) (f : X → Wgt A)
+    (hw : SubLaw w) (hf : ∀ i,IsLaw (f i)) :
+    SubLaw (mixW (subW w p) f) ∧ tot (mixW (subW w p) f)=pr w p := by
+  have hh : tot (mixW (subW w p) f)=pr w p := by
+    rw [mixW_tot]; simp_rw [(hf _).total,avg_const,mul_one,subW_tot]
+  exact ⟨⟨fun i => avg_nonneg (subLaw_sub hw p).nz (fun j => (hf j).nz i),
+    hh ▸ (pr_le_tot hw.nz).trans hw.total⟩,hh⟩
+
+omit [Fintype A] in
+theorem path_patch (w : Wgt X) (p : X→Prop) (f : X → Wgt A) :
+    ∀ i,mixW w f i=mixW (subW w p) f i+mixW (subW w (fun x=>¬ p x)) f i := by
+  intro i
+  unfold mixW subW avg
+  rw [←Finset.sum_add_distrib]; simp_rw [ind_not]
+  exact sum_congr rfl fun j _ => by ring
+
+set_option maxHeartbeats 1000000 in
+theorem path_energy (μ : Wgt A) (w : Wgt X) (q : Wgt B)
+    (f : A → X→B) (hμ : IsLaw μ) (hw : IsLaw w) (hq : IsLaw q)
+    (h : ∀ i j,q (f i j)≠0)
+    (u : ℝ) (hu : 0≤u) (hp : ∀ i,q i ≠0 → bp (-u)≤q i)
+    (l : ℕ) (P : (Fin l→X)→ Prop) (r : ℝ)
+    (hr : pr (draws (Fin l) w) (fun x => ¬ P x)≤r)
+    (C : ℝ) (hc : 0≤C)
+    (hP : ∀ x,P x→ ∀ y,mapW μ (fun i => f i ∘ x) y ≤ bp C * draws (Fin l) q y) :
+    (l:ℝ)* avg μ (fun i => tension (mapW w (f i)) q) ≤
+      num B*log (↑l+1)+(C+r*u*l+1)*log 2 := by
+  classical
+  let F (i : A) := mapW w (f i)
+  let W := draws (Fin l) w
+  let Q := draws (Fin l) q
+  let k (x : Fin l → X) := mapW μ (fun i => f i ∘ x)
+  let g := mixW (subW W P) k
+  let b := mixW (subW W (fun x => ¬ P x)) k
+  let V := mixW μ (fun i => draws (Fin l) (F i))
+  have h0 : ∀ i, lsupp (F i) q := by
+    intro i j hj; obtain ⟨t,ht,rfl⟩ := lsupp_witness hj
+    exact h _ _
+  have hF : ∀ i,IsLaw (F i) := fun i => mapW_law hw (f i)
+  have hV : IsLaw V := mixW_law hμ (fun i => draws_law (hF i))
+  have hQ : IsLaw Q := draws_law hq
+  have hW : IsLaw W := draws_law hw
+  have hk : ∀ i,IsLaw (k i) := fun i => mapW_law hμ _
+  have h1 := traj_charge (l:=l) μ F q hμ hF h0
+  have h2 : ∀ i,V i=g i+b i := by unfold V F; rw [path_repeat]; exact path_patch W P k
+  have hg := path_sub W P k hW.sub hk
+  have hb := path_sub W (fun x => ¬ P x) k hW.sub hk
+  have h2L : 0 ≤ log (2:ℝ) := (Real.log_pos (by norm_num)).le
+  have h3 : tension g Q ≤ C*log 2 := by
+    have hz i : g i ≤ bp C*Q i := by
+      let c := bp C*Q i
+      have hc : 0≤c := mul_nonneg (bp_pos _).le (hQ.nz _)
+      have he (j) : ind (P j)*k j i ≤ c := by
+        by_cases h : P j
+        · rw [ind_one h,one_mul]; exact hP j h i
+        rw [ind_zero h,zero_mul]; exact hc
+      refine le_trans ?_ (hW.avg_le he)
+      simp only [g,mixW,subW,avg,mul_assoc]; rfl
+    refine (tension_le_cap hg.1.nz hQ.nz _ (bp_pos _) hz).trans ?_
+    rw [log_bp]
+    exact (mul_le_mul_of_nonneg_right hg.1.total
+      (mul_nonneg hc h2L)).trans_eq (one_mul _)
+  have h4 : tension b Q ≤ r*(u*l*log 2) := by
+    have hz (i : Fin l → B) : b i ≤ bp (u*l)*Q i := by
+      by_cases he : Q i=0
+      · have ht (j) : k j i=0 := by
+          by_contra h
+          obtain ⟨z,hz,rfl⟩ := lsupp_witness h
+          have ht : Q (f z ∘ j) ≠ 0 := by
+            change ∏ i:Fin l,q (f z (j i)) ≠0
+            rw [Finset.prod_ne_zero_iff]; exact fun i _ => ‹∀ i j,q (f i j)≠0› _ _
+          exact ht he
+        unfold b mixW; simp_rw [ht]; rw [he,avg_zero,mul_zero]
+      have hq := traj_cap q hq u hp i he
+      refine (hb.1.weight_le_one i).trans ?_
+      exact (le_of_eq (by rw [←bp_add,show u*l+ -u*l = 0 by ring,bp_zero])).trans
+        (mul_le_mul_of_nonneg_left hq (bp_pos _).le)
+    refine (tension_le_cap hb.1.nz hQ.nz _ (bp_pos _) hz).trans ?_
+    rw [log_bp]
+    exact mul_le_mul_of_nonneg_right (hb.2.le.trans hr)
+      (by apply mul_nonneg (by positivity) h2L)
+  apply h1.trans
+  refine add_le_add_right ?_ _
+  have h5 := tension_add_le V g b Q h2 hg.1.nz hb.1.nz
+  rw [hV.total] at h5
+  linarith only [h5,h4,h3]
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/ReservedLabels.lean

@@ -1,122 +1,122 @@
-import OAI.Combinatorics.HadwigerCounterexample.FreshGeneratorCorrection
-
-namespace OAI
-
-/-! # Reserved Labels -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Matrix Module LinearMap Submodule Function Finset
-open scoped BigOperators
-namespace StatusAnalysis
-variable {I L : Type} [DecidableEq L] [DecidableEq I] {d e : ℕ}
-open Club
-set_option maxHeartbeats 600000 in
-theorem fresh_single (C : Club I (Signal d e) L) {s : Straps L} {V}
-    (h : C.travels s 4 (view d e) V) (x : Signal d e) (hx : x∈V) :
-    ∃ p:Finset I,C.bundle p s∧ C.contents p=x∧1≤p.card∧p.card≤7 := by
-  classical
-  obtain ⟨hh,hC⟩:= C.travel_now h
-  let Q:= view d e
-  obtain ⟨i,hi,hI,_⟩:= C.yield_after s Q hC ∅ (by simp) (Q x)
-  let p : Finset I:= {i}
-  have hp := C.bundle_one s hi
-  have hr : C.travels (s⊔ C.addrs p) 3 Q V := C.travel_more h (C.addrs p)
-    (fun i=>card_image_le.trans (by unfold p; simp : p.card≤1)) (by norm_num)
-  obtain ⟨q,hq,hQ,hT⟩ := jump_two C hr (ker_two _) (x-C.writes i) (by
-    constructor
-    · exact Submodule.sub_mem _ hx (hh ▸ C.band_write s hi)
-    change Q (x-C.writes i)=0
-    rw [map_sub,hI,sub_self])
-  obtain ⟨ha,hb⟩:= C.bundle_combine hp hq
-  refine ⟨p∪q,ha,?_,?_,(card_union_le ..).trans ?_⟩
-  · change ∑ j∈p∪q,_=_
-    rw [sum_union hb, ←show C.contents q=(∑ j∈q,_) from rfl, hT]
-    simp only [sum_singleton,add_sub_cancel]
-  · exact card_pos.mpr ⟨i, mem_union_left _ (by simp [p])⟩
-  simp only [p,card_singleton]
-  omega
-
-variable {I : Grid → Type} [∀ i,DecidableEq (I i)] {A B : Rates}
-abbrev Congress (I : Grid→Type) (A B : Rates) (L : Type) := ∀ i,Club (I i) (Suite A B i) L
-namespace Guild
-variable (C : Congress I A B L)
-def chapter (s : Straps L) : StatusSp A B := fun i=> (C i).band s
-def excess (s : Straps L) := ∑ i:Grid,overage (chapter C s i)
-
-omit [DecidableEq L] [∀ i,DecidableEq (I i)] in
-theorem excess_bound (s : Straps L) : excess C s ≤8 := by
-  unfold excess
-  exact (Finset.sum_le_sum (g:=fun _=>2) (fun i _=>overage_two
-    (chapter C s i))).trans_eq (by norm_num [Grid,Nodes])
-
-omit [DecidableEq L] [∀ i,DecidableEq (I i)] in
-theorem chapter_mono {s t : Straps L} (h : s≤t) (i) :
-    chapter C t i ≤ chapter C s i := span_mono (fun _ ⟨a,ht,hx⟩=>
-  ⟨a,(C i).zone_smaller h a ht,hx⟩)
-
-def rich (C : Congress I A B L) :=
-  ∀ i:Grid,∀ s:Straps L,sizeB s 902 → ∀ y:View (A i.1) (B i.2),∃ j,
-    (C i).zone s j ∧ view _ _ ((C i).writes j)=y
-
-omit [DecidableEq L] [∀ i,DecidableEq (I i)] in
-theorem rich_covers (h : rich C) (s : Straps L) (hs : sizeB s 902) (i) :
-    coverBase (chapter C s i) := by
-  intro y
-  obtain ⟨j,hj,hy⟩:=h i s hs y
-  exact ⟨⟨_, (C i).band_write s hj⟩,hy⟩
-
-set_option maxHeartbeats 800000 in
-omit [∀ i,DecidableEq (I i)] in
-theorem stable (h : rich C) :
-    ∃ s:Straps L,sizeB s 800 ∧
-      ∀ i:Grid,(C i).travels s 100 (view _ _) (chapter C s i) := by
-  classical
-  have hh (k : ℕ) (hk : k≤ 8) (t : Straps L)
-      (ht : sizeB t ((8-k)*100)) (hb : excess C t≤ k) :
-      ∃ s:Straps L,sizeB s 800 ∧
-      ∀ i:Grid,(C i).travels s 100 (view _ _) (chapter C s i) := by
-    induction k generalizing t with
-    | zero =>
-      refine ⟨t,ht,fun i u hu=>?_⟩
-      let v:=t⊔u
-      have he : sizeB v 900:= fun i=> (card_union_le ..).trans (Nat.add_le_add (ht i) (hu i))
-      constructor
-      · change chapter C v i=chapter C t i
-        have hm (i:Grid) : overage (chapter C t i)=0 := by
-          have hy : overage (chapter C t i) ≤ 0 := le_trans (Finset.single_le_sum (s:=Finset.univ)
-            (fun i _=>Nat.zero_le (overage (chapter C t i))) (Finset.mem_univ i)) hb
-          exact Nat.eq_zero_of_le_zero hy
-        exact eq_of_le_of_not_lt (chapter_mono C le_sup_left i) (fun hx=> Nat.not_lt_zero _
-          ((overage_lt hx (rich_covers C h v (fun i=> (he i).trans (by decide)) i)).trans_eq (hm i)))
-      intro w hw y
-      exact h i (v⊔w) (fun i=> (card_union_le ..).trans (Nat.add_le_add (he i) (hw i))) y
-    | succ k ih =>
-      have hT : sizeB t 800 := fun i=> (ht i).trans (by omega)
-      by_cases hE : ∃ (s:Straps L), sizeB s 100∧∃ i:Grid, chapter C (t⊔s) i < chapter C t i
-      · obtain ⟨u,hu,i,hU⟩:=hE
-        let s:=t⊔u
-        have he : sizeB s ((8-k)*100):= fun i=> (card_union_le ..).trans
-          ((Nat.add_le_add (ht i) (hu i)).trans (by omega))
-        refine ih (by omega) s he ?_
-        have hS : excess C s < excess C t := by
-          unfold excess
-          have h1 := overage_lt hU (rich_covers C h s (fun i=> (he i).trans (by omega)) i)
-          exact Finset.sum_lt_sum (fun i _=> overage_mono (chapter_mono C le_sup_left i))
-            ⟨i,mem_univ _,h1⟩
-        omega
-      refine ⟨t,hT,fun i u hu=>?_⟩
-      constructor
-      · exact eq_of_le_of_not_lt (chapter_mono C (s:=t) (t:=t⊔u) le_sup_left i) (fun hx =>
-          hE ⟨u,hu,i,hx⟩)
-      intro w hw y
-      have he : sizeB (t⊔u) 900:= fun i=> (card_union_le ..).trans (Nat.add_le_add (hT i) (hu i))
-      exact h i ((t⊔u)⊔w) (fun i=> (card_union_le ..).trans (Nat.add_le_add (he i) (hw i))) y
-  exact hh 8 (Nat.le_refl _) ⊥ (by intro i; change (∅:Finset L).card ≤_; simp) (excess_bound C _)
-end Guild
-end StatusAnalysis
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.FreshGeneratorCorrection
+
+namespace OAI
+
+/-! # Reserved Labels -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Matrix Module LinearMap Submodule Function Finset
+open scoped BigOperators
+namespace StatusAnalysis
+variable {I L : Type} [DecidableEq L] [DecidableEq I] {d e : ℕ}
+open Club
+set_option maxHeartbeats 600000 in
+theorem fresh_single (C : Club I (Signal d e) L) {s : Straps L} {V}
+    (h : C.travels s 4 (view d e) V) (x : Signal d e) (hx : x∈V) :
+    ∃ p:Finset I,C.bundle p s∧ C.contents p=x∧1≤p.card∧p.card≤7 := by
+  classical
+  obtain ⟨hh,hC⟩:= C.travel_now h
+  let Q:= view d e
+  obtain ⟨i,hi,hI,_⟩:= C.yield_after s Q hC ∅ (by simp) (Q x)
+  let p : Finset I:= {i}
+  have hp := C.bundle_one s hi
+  have hr : C.travels (s⊔ C.addrs p) 3 Q V := C.travel_more h (C.addrs p)
+    (fun i=>card_image_le.trans (by unfold p; simp : p.card≤1)) (by norm_num)
+  obtain ⟨q,hq,hQ,hT⟩ := jump_two C hr (ker_two _) (x-C.writes i) (by
+    constructor
+    · exact Submodule.sub_mem _ hx (hh ▸ C.band_write s hi)
+    change Q (x-C.writes i)=0
+    rw [map_sub,hI,sub_self])
+  obtain ⟨ha,hb⟩:= C.bundle_combine hp hq
+  refine ⟨p∪q,ha,?_,?_,(card_union_le ..).trans ?_⟩
+  · change ∑ j∈p∪q,_=_
+    rw [sum_union hb, ←show C.contents q=(∑ j∈q,_) from rfl, hT]
+    simp only [sum_singleton,add_sub_cancel]
+  · exact card_pos.mpr ⟨i, mem_union_left _ (by simp [p])⟩
+  simp only [p,card_singleton]
+  omega
+
+variable {I : Grid → Type} [∀ i,DecidableEq (I i)] {A B : Rates}
+abbrev Congress (I : Grid→Type) (A B : Rates) (L : Type) := ∀ i,Club (I i) (Suite A B i) L
+namespace Guild
+variable (C : Congress I A B L)
+def chapter (s : Straps L) : StatusSp A B := fun i=> (C i).band s
+def excess (s : Straps L) := ∑ i:Grid,overage (chapter C s i)
+
+omit [DecidableEq L] [∀ i,DecidableEq (I i)] in
+theorem excess_bound (s : Straps L) : excess C s ≤8 := by
+  unfold excess
+  exact (Finset.sum_le_sum (g:=fun _=>2) (fun i _=>overage_two
+    (chapter C s i))).trans_eq (by norm_num [Grid,Nodes])
+
+omit [DecidableEq L] [∀ i,DecidableEq (I i)] in
+theorem chapter_mono {s t : Straps L} (h : s≤t) (i) :
+    chapter C t i ≤ chapter C s i := span_mono (fun _ ⟨a,ht,hx⟩=>
+  ⟨a,(C i).zone_smaller h a ht,hx⟩)
+
+def rich (C : Congress I A B L) :=
+  ∀ i:Grid,∀ s:Straps L,sizeB s 902 → ∀ y:View (A i.1) (B i.2),∃ j,
+    (C i).zone s j ∧ view _ _ ((C i).writes j)=y
+
+omit [DecidableEq L] [∀ i,DecidableEq (I i)] in
+theorem rich_covers (h : rich C) (s : Straps L) (hs : sizeB s 902) (i) :
+    coverBase (chapter C s i) := by
+  intro y
+  obtain ⟨j,hj,hy⟩:=h i s hs y
+  exact ⟨⟨_, (C i).band_write s hj⟩,hy⟩
+
+set_option maxHeartbeats 800000 in
+omit [∀ i,DecidableEq (I i)] in
+theorem stable (h : rich C) :
+    ∃ s:Straps L,sizeB s 800 ∧
+      ∀ i:Grid,(C i).travels s 100 (view _ _) (chapter C s i) := by
+  classical
+  have hh (k : ℕ) (hk : k≤ 8) (t : Straps L)
+      (ht : sizeB t ((8-k)*100)) (hb : excess C t≤ k) :
+      ∃ s:Straps L,sizeB s 800 ∧
+      ∀ i:Grid,(C i).travels s 100 (view _ _) (chapter C s i) := by
+    induction k generalizing t with
+    | zero =>
+      refine ⟨t,ht,fun i u hu=>?_⟩
+      let v:=t⊔u
+      have he : sizeB v 900:= fun i=> (card_union_le ..).trans (Nat.add_le_add (ht i) (hu i))
+      constructor
+      · change chapter C v i=chapter C t i
+        have hm (i:Grid) : overage (chapter C t i)=0 := by
+          have hy : overage (chapter C t i) ≤ 0 := le_trans (Finset.single_le_sum (s:=Finset.univ)
+            (fun i _=>Nat.zero_le (overage (chapter C t i))) (Finset.mem_univ i)) hb
+          exact Nat.eq_zero_of_le_zero hy
+        exact eq_of_le_of_not_lt (chapter_mono C le_sup_left i) (fun hx=> Nat.not_lt_zero _
+          ((overage_lt hx (rich_covers C h v (fun i=> (he i).trans (by decide)) i)).trans_eq (hm i)))
+      intro w hw y
+      exact h i (v⊔w) (fun i=> (card_union_le ..).trans (Nat.add_le_add (he i) (hw i))) y
+    | succ k ih =>
+      have hT : sizeB t 800 := fun i=> (ht i).trans (by omega)
+      by_cases hE : ∃ (s:Straps L), sizeB s 100∧∃ i:Grid, chapter C (t⊔s) i < chapter C t i
+      · obtain ⟨u,hu,i,hU⟩:=hE
+        let s:=t⊔u
+        have he : sizeB s ((8-k)*100):= fun i=> (card_union_le ..).trans
+          ((Nat.add_le_add (ht i) (hu i)).trans (by omega))
+        refine ih (by omega) s he ?_
+        have hS : excess C s < excess C t := by
+          unfold excess
+          have h1 := overage_lt hU (rich_covers C h s (fun i=> (he i).trans (by omega)) i)
+          exact Finset.sum_lt_sum (fun i _=> overage_mono (chapter_mono C le_sup_left i))
+            ⟨i,mem_univ _,h1⟩
+        omega
+      refine ⟨t,hT,fun i u hu=>?_⟩
+      constructor
+      · exact eq_of_le_of_not_lt (chapter_mono C (s:=t) (t:=t⊔u) le_sup_left i) (fun hx =>
+          hE ⟨u,hu,i,hx⟩)
+      intro w hw y
+      have he : sizeB (t⊔u) 900:= fun i=> (card_union_le ..).trans (Nat.add_le_add (hT i) (hu i))
+      exact h i ((t⊔u)⊔w) (fun i=> (card_union_le ..).trans (Nat.add_le_add (he i) (hw i))) y
+  exact hh 8 (Nat.le_refl _) ⊥ (by intro i; change (∅:Finset L).card ≤_; simp) (excess_bound C _)
+end Guild
+end StatusAnalysis
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/ResidualCutPairs.lean

@@ -1,202 +1,202 @@
-import OAI.Combinatorics.HadwigerCounterexample.AttackCutDecomposition
-
-namespace OAI
-
-/-! # Residual Cut Pairs -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open scoped BigOperators
-open Matrix LinearMap Submodule Module Finset
-variable {p : Shape} {n : ℕ} {I : Type} [Fintype I]
-namespace Volley
-
-def CleanRay (v : Volley p n I) (i : Bool) (R : ℕ) (x : Ray p n) :=
-  ∃ (L : Finset (Label p.b)) (u : LabVals p n), x=labcomb p n L u ∧ L.card≤R ∧
-    Disjoint L (v.marked i)
-
-variable {v : Volley p n I}
-private theorem clean_apply {i : Bool} {R : ℕ} {M : Moment p n} (h : v.clean i R M) (x : Ray p n) :
-    v.CleanRay i R (M *ᵥ x) := by
-  classical
-  obtain ⟨L,Z,rfl,hL,ht⟩ := h
-  refine ⟨L,(fun s => Z s *ᵥ ((labMat p n s)ᵀ *ᵥ x)),?_,hL,ht⟩
-  rw [labcomb_eval,labelSum,Matrix.sum_mulVec]
-  refine Finset.sum_congr rfl fun i _ => ?_
-  simp only [mput,liftM_def,←Matrix.mulVec_mulVec]
-  rw [labMat_act]
-
-private theorem clean_zero (v : Volley p n I) (i : Bool) (R : ℕ) :
-    v.CleanRay i R 0 :=
-  ⟨∅,0,(map_zero _).symm,by simp,by simp⟩
-
-/-- Key coefficients cannot contribute to a short nonattack primal
-combination even if only the primal projection is specified. -/
-private theorem clean_proj {w : I → Bool} {a : Plan p n} (t : Tagging p I) {R q : ℕ}
-    (hb : v.bounded w) (hv : v.avoids a q) (hr : R+14 ≤ q)
-    (x : Ray p n) (z : Place p) (i : Bool) (hx : v.CleanRay i R x)
-    (b : Vec (visits p t z.1)) (he : x-(IP p n i)ᵀ *ᵥ (v.keyM t z.1 *ᵥ b) ∈ sPin a z i) :
-    ∀ j∈v.visitH t i z.1,b j = 0 := by
-  classical
-  let K := v.visitH t i z.1
-  obtain ⟨B,hB,hE,hG,hsel⟩ := hv i
-  obtain ⟨L,u,hx,hL,hdis⟩ := hx
-  let s (j : visits p t z.1) := v.sel j.val
-  let T := K.image s
-  have hk (i' : visits p t z.1) (h : i'∈K) : i'.val∈v.here i :=
-    (v.visitH_here ..).mp h
-  have hs : Set.InjOn s (K : Set _) := by
-    intro x hx y hy h
-    exact Subtype.ext (hsel (hk _ hx) (hk _ hy) h)
-  obtain ⟨y,hy,hZ⟩ := point_comb K s (v.par ∘ Subtype.val) b hs
-  rw [key_proj] at he
-  let r : LabVals p n := withinL p L u - withinL p T y
-  have h : labcomb p n (L∪T) r∈sPin a z i := by
-    rw [show r =_ - _ from rfl,map_sub,← within_eq subset_union_left u,
-      ← within_eq subset_union_right y,← hx, show labcomb p n T y =_ from hZ.symm]
-    exact he
-  have hh : (L∪T).card≤q :=
-     (Finset.card_union_le ..).trans ((Nat.add_le_add hL (Finset.card_image_le.trans
-       (v.visitH_card hb t i z.1))).trans hr)
-  intro j hj
-  have hj' : s j ∈ T := mem_image_of_mem s hj
-  have hj'' : s j ∉ L := fun hh => Finset.disjoint_left.mp hdis hh
-    (mem_image_of_mem _ (hk j hj))
-  have hy' := hB z (L∪T) r h hh _ (mem_union_right _ hj') (hE _ (hk _ hj))
-  unfold r withinL at hy'
-  simp only [Pi.sub_apply,ite_eq_right hj'',ite_eq_left hj',hy j hj,zero_sub,neg_eq_zero] at hy'
-  simpa only [Function.comp_apply,Pi.zero_apply,Pi.smul_apply,smul_eq_mul,baseV,
-    Option.elim',mul_one] using congr_fun hy' none
-
-private theorem clean_sPin {w : I → Bool} {a : Plan p n} (t : Tagging p I) {R q : ℕ}
-    (hb : v.bounded w) (hv : v.avoids a q) (hr : R+14 ≤ q)
-    (x : Ray p n) (z : Place p) (i : Bool) (hx : v.CleanRay i R x)
-    (hg : x∈sPin (v.frozen a t) z i) :
-    x∈sPin a z i := by
-  classical
-  rw [sPin_frozen,Submodule.mem_sup] at hg
-  obtain ⟨y,hy,q',⟨q',⟨b,rfl⟩,rfl⟩,hX⟩ := hg
-  have he : x - ((IP p n i)ᵀ *ᵥ (v.keyM t z.1 *ᵥ b))=y := by
-    rw [← hX]; exact add_sub_cancel_right _ _
-  have h := clean_proj t hb hv hr x z i hx b (he ▸ hy)
-  rw [key_proj,Finset.sum_eq_zero (fun j hj => by rw [h j hj,zero_smul]),sub_zero] at he
-  rwa [he]
-
-private theorem clean_Pin {w : I→Bool} {a : Plan p n} (t : Tagging p I)
-    {R q : ℕ} (hb : v.bounded w) (hv : v.avoids a q) (hr : R+14 ≤ q)
-    (x : Ray p n) (z : Place p) (i : Bool) (hx : v.CleanRay i R x)
-    (hg : IP p n i *ᵥ x ∈ v.frozen a t z) :
-    IP p n i *ᵥ x∈a z := by
-  classical
-  obtain ⟨d,hd,q',⟨b,rfl⟩,hX⟩ := Submodule.mem_sup.mp
-    (show IP p n i *ᵥ x∈a z ⊔ v.keyPlan t z from hg)
-  let f (k : Bool) := (IP p n k)ᵀ
-  have hzero : b=0 := by
-    funext j
-    let k := v.obj j.val
-    let x' := f k *ᵥ (IP p n i *ᵥ x)
-    have h : x' - ((IP p n k)ᵀ *ᵥ (v.keyM t z.1 *ᵥ b))∈sPin a z k := by
-      unfold x'
-      rw [← hX,Matrix.mulVec_add]
-      change f k *ᵥ d + _ - f k *ᵥ (_ *ᵥ _) ∈ _
-      rw [mulVecLin_apply,add_sub_cancel_right]
-      exact ⟨d,hd,rfl⟩
-    have h' : v.CleanRay k R x' := by
-      unfold x' f; rw [Matrix.mulVec_mulVec]
-      by_cases h : k=i
-      · rw [h,IP_self,Matrix.one_mulVec]
-        exact hx
-      rw [IP_cross h,Matrix.zero_mulVec]; exact clean_zero v k R
-    exact clean_proj t hb hv hr x' z k h' b h j (mem_filter.mpr ⟨mem_univ _,rfl⟩)
-  rw [hzero,map_zero,add_zero] at hX
-  rwa [← hX]
-
-end Volley
-
-theorem orth_delta_probe {f b : Plan p n} {x : Xpair p n} {C : ChanOut p n} {j}
-    (h : orth p C f b j x) (i : Bool) (z : Place p) (φ : Ray p n)
-    (hφ : φ∈annih (sPin f (flipZ p z) i)) :
-    C z *ᵥ (IP p n i *ᵥ ((x i).val z.1 *ᵥ φ)) ∈ hPin b z j := by
-  classical
-  rw [← annih_annih (hPin b z j), annih_mem]
-  intro y hy
-  rw [← pure_ip]
-  let Q := IP p n i *ᵥ φ
-  have hQ := (ip_annih ..).mpr hφ
-  let D : ChanOut p n := Pi.single (flipZ p z) (vecMulVec y Q)
-  have hD : D∈deltaSpace p f b j := by
-    refine (deltaSpace_mem _).mpr (fun z' => ?_)
-    by_cases hz : z'=flipZ p z
-    · subst z'
-      unfold D; rw [Pi.single_eq_same,flipZ_flip]
-      exact outer_in_box y Q hy hQ
-    simp [D,hz]
-  have hg := h D hD 0 (Submodule.zero_mem _)
-  change ∑ i, mpair ((chanDeriv p C D+0) i) (purePair p n x i) = _ at hg
-  rw [add_zero,Finset.sum_eq_single z.1] at hg
-  · let T := (C z)ᵀ * vecMulVec y Q
-    let X := purePair p n x z.1
-    have hh : mpair T X = dotProduct (C z *ᵥ (X *ᵥ Q)) y := by
-      unfold T; rw [mul_vecMulVec,mpair_comm,mpair_outer,evmat]
-      rw [dotProduct_comm, dotProduct_transpose_mulVec,dotProduct_comm]
-    change dotProduct (C z *ᵥ (X *ᵥ Q)) y = _
-    rw [← hh]
-    have hZ : z≠flipZ p z := by cases z with | mk e c => cases c <;> simp [flipZ]
-    have h1 : D z=0 := Pi.single_eq_of_ne hZ _
-    have h2 : D (flipZ p z)=vecMulVec y Q := Pi.single_eq_same _ _
-    rcases z with ⟨e,c|c⟩
-    · change mpair ((C (e,true))ᵀ * D (e,false)+(D (e,true))ᵀ * C (e,false)) X=0 at hg
-      change D (e,true)=_ at h2
-      rw [h1,h2,Matrix.mul_zero,zero_add,transpose_vecMulVec,vecMulVec_mul] at hg
-      unfold T; rw [mul_vecMulVec, Matrix.mulVec_transpose,mpair_comm,mpair_outer,
-        ←evmat_transpose, show Xᵀ=X from purePair_sym x e]
-      rw [mpair_comm,mpair_outer] at hg
-      exact hg
-    change mpair ((C (e,true))ᵀ * D (e,false)+(D (e,true))ᵀ * C (e,false)) X=0 at hg
-    change D (e,false)=_ at h2
-    rw [h1,Matrix.transpose_zero,Matrix.zero_mul,add_zero,h2] at hg
-    exact hg
-  · intro k _ hk
-    have h1 (i : Bool) : D (k,i)=0 := Pi.single_eq_of_ne (show (_,_)≠flipZ p z from
-      fun hh => hk (congrArg Prod.fst hh)) _
-    simp only [chanDeriv,chanInner,Pi.add_apply,h1,Matrix.transpose_zero,Matrix.mul_zero,
-      Matrix.zero_mul,zero_add]
-    rw [mpair_comm,map_zero]
-  simp
-
-namespace Volley
-variable {v : Volley p n I}
-theorem clean_effective {w : I→Bool} {a b : Plan p n} (t : Tagging p I)
-    {q R : ℕ} (hb : v.bounded w) (hv : v.avoids a q) (hr : R+14≤q)
-    {j : Bool} (M : Cross p n) (x : Xpair p n)
-    (hh : orth p (channelOut p M j) (v.frozen a t) b j x)
-    (hg : tableInj a b M) (i : Bool) (hx : ∀ e,v.clean i R ((x i).val e)) :
-    (x i).val∈effective a i := by
-  classical
-  refine effective_mem.mpr ⟨(x i).property,fun e => ?_⟩
-  let A := (x i).val e
-  let S (z) := sPin (v.frozen a t) (e,z) i
-  have hd (c : Bool) (φ : Ray p n) (hφ : φ∈annih (S (!c))) : A *ᵥ φ=0 := by
-    have hray := clean_apply (hx e) φ
-    have hm := orth_ip_frozen hh i (e,c) φ hφ
-    exact hg (e,c) i j (A *ᵥ φ) (clean_Pin t hb hv hr _ _ i hray hm)
-      (orth_delta_probe hh i (e,c) φ hφ)
-  have hsym : Aᵀ=A := orth_pair_sym x e i
-  have h (c : Bool) : colSp A ≤ sPin a (e,c) i := by
-    have hh' : colSp A ≤ S c := by
-      have hf : colSp A ≤ annih (annih (S c)) := (colSp_kill ..).mpr (fun φ hφ => by
-        rw [hsym]
-        exact hd (!c) φ (by simpa using hφ))
-      rwa [annih_annih] at hf
-    rintro x' ⟨y,rfl⟩
-    exact clean_sPin t hb hv hr _ _ i (clean_apply (hx e) y) (hh' ⟨y,rfl⟩)
-  change A∈box _ _
-  rw [box_mem,hsym]
-  exact ⟨h _,h _⟩
-
-end Volley
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.AttackCutDecomposition
+
+namespace OAI
+
+/-! # Residual Cut Pairs -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open scoped BigOperators
+open Matrix LinearMap Submodule Module Finset
+variable {p : Shape} {n : ℕ} {I : Type} [Fintype I]
+namespace Volley
+
+def CleanRay (v : Volley p n I) (i : Bool) (R : ℕ) (x : Ray p n) :=
+  ∃ (L : Finset (Label p.b)) (u : LabVals p n), x=labcomb p n L u ∧ L.card≤R ∧
+    Disjoint L (v.marked i)
+
+variable {v : Volley p n I}
+private theorem clean_apply {i : Bool} {R : ℕ} {M : Moment p n} (h : v.clean i R M) (x : Ray p n) :
+    v.CleanRay i R (M *ᵥ x) := by
+  classical
+  obtain ⟨L,Z,rfl,hL,ht⟩ := h
+  refine ⟨L,(fun s => Z s *ᵥ ((labMat p n s)ᵀ *ᵥ x)),?_,hL,ht⟩
+  rw [labcomb_eval,labelSum,Matrix.sum_mulVec]
+  refine Finset.sum_congr rfl fun i _ => ?_
+  simp only [mput,liftM_def,←Matrix.mulVec_mulVec]
+  rw [labMat_act]
+
+private theorem clean_zero (v : Volley p n I) (i : Bool) (R : ℕ) :
+    v.CleanRay i R 0 :=
+  ⟨∅,0,(map_zero _).symm,by simp,by simp⟩
+
+/-- Key coefficients cannot contribute to a short nonattack primal
+combination even if only the primal projection is specified. -/
+private theorem clean_proj {w : I → Bool} {a : Plan p n} (t : Tagging p I) {R q : ℕ}
+    (hb : v.bounded w) (hv : v.avoids a q) (hr : R+14 ≤ q)
+    (x : Ray p n) (z : Place p) (i : Bool) (hx : v.CleanRay i R x)
+    (b : Vec (visits p t z.1)) (he : x-(IP p n i)ᵀ *ᵥ (v.keyM t z.1 *ᵥ b) ∈ sPin a z i) :
+    ∀ j∈v.visitH t i z.1,b j = 0 := by
+  classical
+  let K := v.visitH t i z.1
+  obtain ⟨B,hB,hE,hG,hsel⟩ := hv i
+  obtain ⟨L,u,hx,hL,hdis⟩ := hx
+  let s (j : visits p t z.1) := v.sel j.val
+  let T := K.image s
+  have hk (i' : visits p t z.1) (h : i'∈K) : i'.val∈v.here i :=
+    (v.visitH_here ..).mp h
+  have hs : Set.InjOn s (K : Set _) := by
+    intro x hx y hy h
+    exact Subtype.ext (hsel (hk _ hx) (hk _ hy) h)
+  obtain ⟨y,hy,hZ⟩ := point_comb K s (v.par ∘ Subtype.val) b hs
+  rw [key_proj] at he
+  let r : LabVals p n := withinL p L u - withinL p T y
+  have h : labcomb p n (L∪T) r∈sPin a z i := by
+    rw [show r =_ - _ from rfl,map_sub,← within_eq subset_union_left u,
+      ← within_eq subset_union_right y,← hx, show labcomb p n T y =_ from hZ.symm]
+    exact he
+  have hh : (L∪T).card≤q :=
+     (Finset.card_union_le ..).trans ((Nat.add_le_add hL (Finset.card_image_le.trans
+       (v.visitH_card hb t i z.1))).trans hr)
+  intro j hj
+  have hj' : s j ∈ T := mem_image_of_mem s hj
+  have hj'' : s j ∉ L := fun hh => Finset.disjoint_left.mp hdis hh
+    (mem_image_of_mem _ (hk j hj))
+  have hy' := hB z (L∪T) r h hh _ (mem_union_right _ hj') (hE _ (hk _ hj))
+  unfold r withinL at hy'
+  simp only [Pi.sub_apply,ite_eq_right hj'',ite_eq_left hj',hy j hj,zero_sub,neg_eq_zero] at hy'
+  simpa only [Function.comp_apply,Pi.zero_apply,Pi.smul_apply,smul_eq_mul,baseV,
+    Option.elim',mul_one] using congr_fun hy' none
+
+private theorem clean_sPin {w : I → Bool} {a : Plan p n} (t : Tagging p I) {R q : ℕ}
+    (hb : v.bounded w) (hv : v.avoids a q) (hr : R+14 ≤ q)
+    (x : Ray p n) (z : Place p) (i : Bool) (hx : v.CleanRay i R x)
+    (hg : x∈sPin (v.frozen a t) z i) :
+    x∈sPin a z i := by
+  classical
+  rw [sPin_frozen,Submodule.mem_sup] at hg
+  obtain ⟨y,hy,q',⟨q',⟨b,rfl⟩,rfl⟩,hX⟩ := hg
+  have he : x - ((IP p n i)ᵀ *ᵥ (v.keyM t z.1 *ᵥ b))=y := by
+    rw [← hX]; exact add_sub_cancel_right _ _
+  have h := clean_proj t hb hv hr x z i hx b (he ▸ hy)
+  rw [key_proj,Finset.sum_eq_zero (fun j hj => by rw [h j hj,zero_smul]),sub_zero] at he
+  rwa [he]
+
+private theorem clean_Pin {w : I→Bool} {a : Plan p n} (t : Tagging p I)
+    {R q : ℕ} (hb : v.bounded w) (hv : v.avoids a q) (hr : R+14 ≤ q)
+    (x : Ray p n) (z : Place p) (i : Bool) (hx : v.CleanRay i R x)
+    (hg : IP p n i *ᵥ x ∈ v.frozen a t z) :
+    IP p n i *ᵥ x∈a z := by
+  classical
+  obtain ⟨d,hd,q',⟨b,rfl⟩,hX⟩ := Submodule.mem_sup.mp
+    (show IP p n i *ᵥ x∈a z ⊔ v.keyPlan t z from hg)
+  let f (k : Bool) := (IP p n k)ᵀ
+  have hzero : b=0 := by
+    funext j
+    let k := v.obj j.val
+    let x' := f k *ᵥ (IP p n i *ᵥ x)
+    have h : x' - ((IP p n k)ᵀ *ᵥ (v.keyM t z.1 *ᵥ b))∈sPin a z k := by
+      unfold x'
+      rw [← hX,Matrix.mulVec_add]
+      change f k *ᵥ d + _ - f k *ᵥ (_ *ᵥ _) ∈ _
+      rw [mulVecLin_apply,add_sub_cancel_right]
+      exact ⟨d,hd,rfl⟩
+    have h' : v.CleanRay k R x' := by
+      unfold x' f; rw [Matrix.mulVec_mulVec]
+      by_cases h : k=i
+      · rw [h,IP_self,Matrix.one_mulVec]
+        exact hx
+      rw [IP_cross h,Matrix.zero_mulVec]; exact clean_zero v k R
+    exact clean_proj t hb hv hr x' z k h' b h j (mem_filter.mpr ⟨mem_univ _,rfl⟩)
+  rw [hzero,map_zero,add_zero] at hX
+  rwa [← hX]
+
+end Volley
+
+theorem orth_delta_probe {f b : Plan p n} {x : Xpair p n} {C : ChanOut p n} {j}
+    (h : orth p C f b j x) (i : Bool) (z : Place p) (φ : Ray p n)
+    (hφ : φ∈annih (sPin f (flipZ p z) i)) :
+    C z *ᵥ (IP p n i *ᵥ ((x i).val z.1 *ᵥ φ)) ∈ hPin b z j := by
+  classical
+  rw [← annih_annih (hPin b z j), annih_mem]
+  intro y hy
+  rw [← pure_ip]
+  let Q := IP p n i *ᵥ φ
+  have hQ := (ip_annih ..).mpr hφ
+  let D : ChanOut p n := Pi.single (flipZ p z) (vecMulVec y Q)
+  have hD : D∈deltaSpace p f b j := by
+    refine (deltaSpace_mem _).mpr (fun z' => ?_)
+    by_cases hz : z'=flipZ p z
+    · subst z'
+      unfold D; rw [Pi.single_eq_same,flipZ_flip]
+      exact outer_in_box y Q hy hQ
+    simp [D,hz]
+  have hg := h D hD 0 (Submodule.zero_mem _)
+  change ∑ i, mpair ((chanDeriv p C D+0) i) (purePair p n x i) = _ at hg
+  rw [add_zero,Finset.sum_eq_single z.1] at hg
+  · let T := (C z)ᵀ * vecMulVec y Q
+    let X := purePair p n x z.1
+    have hh : mpair T X = dotProduct (C z *ᵥ (X *ᵥ Q)) y := by
+      unfold T; rw [mul_vecMulVec,mpair_comm,mpair_outer,evmat]
+      rw [dotProduct_comm, dotProduct_transpose_mulVec,dotProduct_comm]
+    change dotProduct (C z *ᵥ (X *ᵥ Q)) y = _
+    rw [← hh]
+    have hZ : z≠flipZ p z := by cases z with | mk e c => cases c <;> simp [flipZ]
+    have h1 : D z=0 := Pi.single_eq_of_ne hZ _
+    have h2 : D (flipZ p z)=vecMulVec y Q := Pi.single_eq_same _ _
+    rcases z with ⟨e,c|c⟩
+    · change mpair ((C (e,true))ᵀ * D (e,false)+(D (e,true))ᵀ * C (e,false)) X=0 at hg
+      change D (e,true)=_ at h2
+      rw [h1,h2,Matrix.mul_zero,zero_add,transpose_vecMulVec,vecMulVec_mul] at hg
+      unfold T; rw [mul_vecMulVec, Matrix.mulVec_transpose,mpair_comm,mpair_outer,
+        ←evmat_transpose, show Xᵀ=X from purePair_sym x e]
+      rw [mpair_comm,mpair_outer] at hg
+      exact hg
+    change mpair ((C (e,true))ᵀ * D (e,false)+(D (e,true))ᵀ * C (e,false)) X=0 at hg
+    change D (e,false)=_ at h2
+    rw [h1,Matrix.transpose_zero,Matrix.zero_mul,add_zero,h2] at hg
+    exact hg
+  · intro k _ hk
+    have h1 (i : Bool) : D (k,i)=0 := Pi.single_eq_of_ne (show (_,_)≠flipZ p z from
+      fun hh => hk (congrArg Prod.fst hh)) _
+    simp only [chanDeriv,chanInner,Pi.add_apply,h1,Matrix.transpose_zero,Matrix.mul_zero,
+      Matrix.zero_mul,zero_add]
+    rw [mpair_comm,map_zero]
+  simp
+
+namespace Volley
+variable {v : Volley p n I}
+theorem clean_effective {w : I→Bool} {a b : Plan p n} (t : Tagging p I)
+    {q R : ℕ} (hb : v.bounded w) (hv : v.avoids a q) (hr : R+14≤q)
+    {j : Bool} (M : Cross p n) (x : Xpair p n)
+    (hh : orth p (channelOut p M j) (v.frozen a t) b j x)
+    (hg : tableInj a b M) (i : Bool) (hx : ∀ e,v.clean i R ((x i).val e)) :
+    (x i).val∈effective a i := by
+  classical
+  refine effective_mem.mpr ⟨(x i).property,fun e => ?_⟩
+  let A := (x i).val e
+  let S (z) := sPin (v.frozen a t) (e,z) i
+  have hd (c : Bool) (φ : Ray p n) (hφ : φ∈annih (S (!c))) : A *ᵥ φ=0 := by
+    have hray := clean_apply (hx e) φ
+    have hm := orth_ip_frozen hh i (e,c) φ hφ
+    exact hg (e,c) i j (A *ᵥ φ) (clean_Pin t hb hv hr _ _ i hray hm)
+      (orth_delta_probe hh i (e,c) φ hφ)
+  have hsym : Aᵀ=A := orth_pair_sym x e i
+  have h (c : Bool) : colSp A ≤ sPin a (e,c) i := by
+    have hh' : colSp A ≤ S c := by
+      have hf : colSp A ≤ annih (annih (S c)) := (colSp_kill ..).mpr (fun φ hφ => by
+        rw [hsym]
+        exact hd (!c) φ (by simpa using hφ))
+      rwa [annih_annih] at hf
+    rintro x' ⟨y,rfl⟩
+    exact clean_sPin t hb hv hr _ _ i (clean_apply (hx e) y) (hh' ⟨y,rfl⟩)
+  change A∈box _ _
+  rw [box_mem,hsym]
+  exact ⟨h _,h _⟩
+
+end Volley
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/ResidualRegularity.lean

@@ -1,107 +1,107 @@
-import OAI.Combinatorics.HadwigerCounterexample.RectangleRegularity
-
-namespace OAI
-
-/-! # Residual Regularity -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Finset Matrix LinearMap Function Filter Real
-open scoped BigOperators
-variable {A B I : Type} [Fintype A] [Fintype B] [Fintype I]
-
-def wanes (u : Wgt I) (w : Wgt A) (f : I→Wgt A) (p : A→B) (ε : ℝ) :=
-  ∀ h : Wgt A,(∀ x,|h x| ≤ 1) →
-    avg u (fun i => |dip w (fun x=> f i x - banner w p (f i) x) h|) ≤ ε
-def hits (u : Wgt I) (w : Wgt A) (f : I→ Wgt A) (p : A→ B) :=
-  avg u (fun i => ode w (banner w p (f i)))
-
-private def twistSign (b : ℝ) := decide (0≤ b)
-private theorem twistabs (b : ℝ) : b*swab (twistSign b)=|b| := by
-  classical by_cases h : 0≤b <;> simp [swab,twistSign,h,abs_of_nonneg,abs_of_neg,lt_of_not_ge]
-
-set_option maxHeartbeats 600000 in
-theorem tilt_test (w : Wgt A) (u : Wgt I) (hu : ∀ i,0 ≤ u i) (f : I → Wgt A) (h : Wgt A)
-    (hh : ∀ x,|h x|≤1) :
-    ∃ p : A→Bool, avg u (fun i=>|dip w (f i) h|) ≤ avg u (fun i => |dip w (f i) (swab∘ p)|) := by
-  classical
-  let q (i:I) := swab (twistSign (dip w (f i) h))
-  let V (x) := avg u (fun i=> f i x * q i)
-  have hx (h : Wgt A) :
-      avg u (fun i=> dip w (f i) h * q i)=dip w V h := by
-    unfold V dip; simp_rw [← avg_mul]
-    rw [avg_avg]
-    refine avg_congr fun i _=> avg_congr fun j _=>by ring
-  let p (x:A) := twistSign (w x*V x)
-  refine ⟨p,?_⟩
-  have hV : dip w V h ≤ dip w V (swab ∘ p) := by
-    unfold dip avg; refine Finset.sum_le_sum fun i _=> ?_
-    dsimp only [Function.comp_apply,p]
-    set t := w i*V i with ht
-    rw [←mul_assoc,←mul_assoc,←ht,twistabs]
-    refine (le_abs_self _).trans ?_
-    rw [abs_mul]
-    exact (mul_le_mul_of_nonneg_left (hh _) (abs_nonneg _)).trans_eq (mul_one _)
-  have h0 i :
-      |dip w (f i) h|=dip w (f i) h*q i := (twistabs ..).symm
-  simp_rw [h0,hx]; rw [←hx (swab ∘ p)] at hV
-  apply le_trans hV
-  apply avg_mono hu
-  intro i
-  rw [← show |dip w (f i) (swab∘p)* q i|=|dip w (f i) (swab∘p)| by rw [abs_mul,swab_abs,mul_one]]
-  exact le_abs_self _
-
-theorem mean_sq (u : Wgt I) (hu : IsLaw u) (f : Wgt I) :
-    avg u f ^ 2 ≤ avg u (fun i=> f i^2) := by
-  simpa only [mul_one,one_pow, hu.avg_const] using avg_CS hu.nz f (fun _=>1)
-
-set_option maxHeartbeats 800000 in
-theorem erosive (M ε : ℝ) (hM : 0≤M) (hε : 0<ε) :
-    ∃ k:ℕ,∀ (A I : Type) [Fintype A] [Fintype I]
-      (u : Wgt I) (w : Wgt A) (f : I→Wgt A),
-      IsLaw u → IsLaw w → (∀ i j,|f i j|≤ M) →
-      ∃ l:ℕ,l≤ k∧∃ p:A→Fin l,wanes u w f p ε := by
-  classical
-  obtain ⟨n,hn⟩:=exists_nat_gt (M^2/ε^2)
-  rw [div_lt_iff₀ (by positivity)] at hn
-  refine ⟨2^n,fun A I _ _ u w f hu hw hf =>?_⟩
-  by_contra! h
-  have hh (i:ℕ) (hi : i≤ n) :
-      ∃ p : A→ Fin (2^i),i*ε^2 ≤ hits u w f p := by
-    induction i with
-    | zero => exact ⟨fun _=>0,(by simp only [Nat.cast_zero,zero_mul,hits]; exact avg_nonneg hu.nz (fun i=>ode_nonneg hw.nz _))⟩
-    | succ i ih =>
-      obtain ⟨p,hp⟩:=ih (by omega)
-      obtain h := h (2^i) (Nat.pow_le_pow_right (by decide) (by omega)) p
-      let T (i:I) (x:A) := f i x-banner w p (f i) x
-      unfold wanes at h; push Not at h; obtain ⟨a,ha,h⟩:=h
-      obtain ⟨s,hs⟩:=tilt_test w u hu.nz T a ha
-      let q:= swab∘s
-      let e : (Fin (2^i) × Bool)≃ Fin (2^(i+1)) := Fintype.equivFinOfCardEq (by simp [pow_succ])
-      let b x := e (p x,s x)
-      let P := Prod.fst ∘ e.symm; let Q:= swab ∘ Prod.snd ∘ e.symm
-      have hP : P∘b=p := by funext i; simp [P,b]
-      have hQ : Q∘b=q := by funext i; simp [q,Q,b]
-      have he x : ode w (banner w p (f x)) + dip w (T x) q ^2 ≤ ode w (banner w b (f x)) := by
-        have he := archive_gain hw.sub (f x) b P Q (fun i=>by unfold Q; simp [swab_abs])
-        rw [hP,hQ] at he
-        change ode _ _+dip w (fun i=> f x i-banner w p (f x) i) q ^2≤_
-        linarith only [he]
-      let V i:= |dip w (T i) q|
-      have hz : ε ≤ avg u V := h.le.trans hs
-      have hb := (pow_le_pow_left₀ hε.le hz 2).trans (mean_sq u hu V)
-      have hh := avg_mono hu.nz he
-      rw [avg_add] at hh
-      change hits u w f p + _ ≤ hits u w f b at hh
-      unfold V at hb; simp_rw [sq_abs] at hb
-      refine ⟨b,?_⟩
-      push_cast; linarith only [hp,hb,hh]
-  obtain ⟨p,hp⟩ := hh n le_rfl
-  have h (i:I) : ∀ x:A,|banner w p (f i) x|≤ M :=
-    fun i'=> cashbook_bound w hw.nz p _ _ hM (hf i) (p i')
-  exact not_lt_of_ge (hp.trans (hu.avg_le (fun i=> ode_upper hw.sub _ M (h i)))) hn
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.RectangleRegularity
+
+namespace OAI
+
+/-! # Residual Regularity -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Finset Matrix LinearMap Function Filter Real
+open scoped BigOperators
+variable {A B I : Type} [Fintype A] [Fintype B] [Fintype I]
+
+def wanes (u : Wgt I) (w : Wgt A) (f : I→Wgt A) (p : A→B) (ε : ℝ) :=
+  ∀ h : Wgt A,(∀ x,|h x| ≤ 1) →
+    avg u (fun i => |dip w (fun x=> f i x - banner w p (f i) x) h|) ≤ ε
+def hits (u : Wgt I) (w : Wgt A) (f : I→ Wgt A) (p : A→ B) :=
+  avg u (fun i => ode w (banner w p (f i)))
+
+private def twistSign (b : ℝ) := decide (0≤ b)
+private theorem twistabs (b : ℝ) : b*swab (twistSign b)=|b| := by
+  classical by_cases h : 0≤b <;> simp [swab,twistSign,h,abs_of_nonneg,abs_of_neg,lt_of_not_ge]
+
+set_option maxHeartbeats 600000 in
+theorem tilt_test (w : Wgt A) (u : Wgt I) (hu : ∀ i,0 ≤ u i) (f : I → Wgt A) (h : Wgt A)
+    (hh : ∀ x,|h x|≤1) :
+    ∃ p : A→Bool, avg u (fun i=>|dip w (f i) h|) ≤ avg u (fun i => |dip w (f i) (swab∘ p)|) := by
+  classical
+  let q (i:I) := swab (twistSign (dip w (f i) h))
+  let V (x) := avg u (fun i=> f i x * q i)
+  have hx (h : Wgt A) :
+      avg u (fun i=> dip w (f i) h * q i)=dip w V h := by
+    unfold V dip; simp_rw [← avg_mul]
+    rw [avg_avg]
+    refine avg_congr fun i _=> avg_congr fun j _=>by ring
+  let p (x:A) := twistSign (w x*V x)
+  refine ⟨p,?_⟩
+  have hV : dip w V h ≤ dip w V (swab ∘ p) := by
+    unfold dip avg; refine Finset.sum_le_sum fun i _=> ?_
+    dsimp only [Function.comp_apply,p]
+    set t := w i*V i with ht
+    rw [←mul_assoc,←mul_assoc,←ht,twistabs]
+    refine (le_abs_self _).trans ?_
+    rw [abs_mul]
+    exact (mul_le_mul_of_nonneg_left (hh _) (abs_nonneg _)).trans_eq (mul_one _)
+  have h0 i :
+      |dip w (f i) h|=dip w (f i) h*q i := (twistabs ..).symm
+  simp_rw [h0,hx]; rw [←hx (swab ∘ p)] at hV
+  apply le_trans hV
+  apply avg_mono hu
+  intro i
+  rw [← show |dip w (f i) (swab∘p)* q i|=|dip w (f i) (swab∘p)| by rw [abs_mul,swab_abs,mul_one]]
+  exact le_abs_self _
+
+theorem mean_sq (u : Wgt I) (hu : IsLaw u) (f : Wgt I) :
+    avg u f ^ 2 ≤ avg u (fun i=> f i^2) := by
+  simpa only [mul_one,one_pow, hu.avg_const] using avg_CS hu.nz f (fun _=>1)
+
+set_option maxHeartbeats 800000 in
+theorem erosive (M ε : ℝ) (hM : 0≤M) (hε : 0<ε) :
+    ∃ k:ℕ,∀ (A I : Type) [Fintype A] [Fintype I]
+      (u : Wgt I) (w : Wgt A) (f : I→Wgt A),
+      IsLaw u → IsLaw w → (∀ i j,|f i j|≤ M) →
+      ∃ l:ℕ,l≤ k∧∃ p:A→Fin l,wanes u w f p ε := by
+  classical
+  obtain ⟨n,hn⟩:=exists_nat_gt (M^2/ε^2)
+  rw [div_lt_iff₀ (by positivity)] at hn
+  refine ⟨2^n,fun A I _ _ u w f hu hw hf =>?_⟩
+  by_contra! h
+  have hh (i:ℕ) (hi : i≤ n) :
+      ∃ p : A→ Fin (2^i),i*ε^2 ≤ hits u w f p := by
+    induction i with
+    | zero => exact ⟨fun _=>0,(by simp only [Nat.cast_zero,zero_mul,hits]; exact avg_nonneg hu.nz (fun i=>ode_nonneg hw.nz _))⟩
+    | succ i ih =>
+      obtain ⟨p,hp⟩:=ih (by omega)
+      obtain h := h (2^i) (Nat.pow_le_pow_right (by decide) (by omega)) p
+      let T (i:I) (x:A) := f i x-banner w p (f i) x
+      unfold wanes at h; push Not at h; obtain ⟨a,ha,h⟩:=h
+      obtain ⟨s,hs⟩:=tilt_test w u hu.nz T a ha
+      let q:= swab∘s
+      let e : (Fin (2^i) × Bool)≃ Fin (2^(i+1)) := Fintype.equivFinOfCardEq (by simp [pow_succ])
+      let b x := e (p x,s x)
+      let P := Prod.fst ∘ e.symm; let Q:= swab ∘ Prod.snd ∘ e.symm
+      have hP : P∘b=p := by funext i; simp [P,b]
+      have hQ : Q∘b=q := by funext i; simp [q,Q,b]
+      have he x : ode w (banner w p (f x)) + dip w (T x) q ^2 ≤ ode w (banner w b (f x)) := by
+        have he := archive_gain hw.sub (f x) b P Q (fun i=>by unfold Q; simp [swab_abs])
+        rw [hP,hQ] at he
+        change ode _ _+dip w (fun i=> f x i-banner w p (f x) i) q ^2≤_
+        linarith only [he]
+      let V i:= |dip w (T i) q|
+      have hz : ε ≤ avg u V := h.le.trans hs
+      have hb := (pow_le_pow_left₀ hε.le hz 2).trans (mean_sq u hu V)
+      have hh := avg_mono hu.nz he
+      rw [avg_add] at hh
+      change hits u w f p + _ ≤ hits u w f b at hh
+      unfold V at hb; simp_rw [sq_abs] at hb
+      refine ⟨b,?_⟩
+      push_cast; linarith only [hp,hb,hh]
+  obtain ⟨p,hp⟩ := hh n le_rfl
+  have h (i:I) : ∀ x:A,|banner w p (f i) x|≤ M :=
+    fun i'=> cashbook_bound w hw.nz p _ _ hM (hf i) (p i')
+  exact not_lt_of_ge (hp.trans (hu.avg_le (fun i=> ode_upper hw.sub _ M (h i)))) hn
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/ResponseAnnihilators.lean

@@ -1,206 +1,206 @@
-import OAI.Combinatorics.HadwigerCounterexample.FrozenProjections
-
-namespace OAI
-
-/-! # Response Annihilators -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Matrix Finset LinearMap Submodule Module
-open scoped BigOperators
-variable {p : Shape} {n : ℕ}
-variable {I : Type} [Fintype I]
-
-def dotL (x : Vec I) : Vec I →ₗ[F] F where
-  toFun y := dotProduct x y
-  map_add' u v := dotProduct_add x _ _
-  map_smul' b u := by
-    simp only [dotProduct,Pi.smul_apply,RingHom.id_apply,smul_eq_mul,mul_sum,mul_left_comm]
-
-theorem dotL_surj (x : Vec I →ₗ[F] F) : ∃ y : Vec I,x=dotL y := by
-  classical
-  let y (i:I) := x (Pi.single i 1)
-  refine ⟨y,LinearMap.ext fun v => ?_⟩
-  have he : x v=x (∑ i, Pi.single i (v i)) := by rw [Finset.univ_sum_single]
-  rw [he,map_sum]
-  change (∑ i,x (Pi.single i (v i)))=∑ i,y i*v i
-  refine Finset.sum_congr rfl fun i _ => ?_
-  rw [show Pi.single i (v i)=v i • (Pi.single i 1 : Vec I) from (by
-    funext j
-    by_cases h : j = i
-    · simp [h]
-    simp [Pi.single_eq_of_ne h]),
-    map_smul]
-  exact mul_comm _ _
-
-private theorem protection_test {S : Space (Ray p n)} {q} {E L : Finset (Label p.b)}
-    (h : protectedBy p S q E) {s} (hs : s∈L) (he : s∉E) (hl : L.card≤q)
-    (ψ : Vec (AIdx p.g n)) :
-    ∃ x ∈ annih S,∀ j∈L,(labMat p n j)ᵀ *ᵥ x= if j=s then ψ else 0 := by
-  classical
-  let P := S.subtype.coprod (labcomb p n L)
-  let Q := dotL ψ ∘ₗ LinearMap.proj s ∘ₗ (LinearMap.snd F S (LabVals p n))
-  obtain ⟨f,hf⟩ : ∃ f,f ∘ₗ P=Q := by
-    refine HadwigerCounterexample.mem_range_comp (show LinearMap.ker P≤LinearMap.ker Q from ?_)
-    rintro ⟨w,z⟩ hw
-    change w.val + labcomb p n L z=0 at hw
-    have hb : labcomb p n L z ∈ S := by
-      rw [show labcomb p n L z=w.val from add_left_cancel (hw.trans (char_two w.val).symm)]
-      exact w.property
-    change dotProduct ψ (z s)=0
-    rw [h L z hb hl s hs he,dotProduct_zero]
-  obtain ⟨x,rfl⟩ := dotL_surj f
-  refine ⟨x,?_,fun j hj => ?_⟩
-  · rw [annih_mem]; intro y hy
-    have hh := LinearMap.congr_fun hf (⟨y,hy⟩,0)
-    change dotProduct x (y+labcomb p n L 0)=dotProduct ψ 0 at hh
-    rw [map_zero,add_zero,dotProduct_zero] at hh
-    exact hh
-  have h1 (z : Vec (AIdx p.g n)) : dotProduct z ((labMat p n j)ᵀ *ᵥ x)=
-      if j=s then dotProduct ψ z else 0 := by
-    let y : LabVals p n := Pi.single j z
-    have hh := LinearMap.congr_fun hf (0,y)
-    change dotProduct x (0+labcomb p n L y)=dotProduct ψ (y s) at hh
-    have hh' : labcomb p n L y = putLab p n j z := by
-      rw [labcomb_eval,Finset.sum_eq_single j]
-      · simp [y]
-      · intro k _ hk; simp [y,Pi.single_eq_of_ne hk]
-      simp [hj]
-    rw [dotProduct_transpose_mulVec,labMat_act]
-    rw [zero_add,hh'] at hh
-    rw [hh]
-    by_cases h : j = s
-    · simp [y,h]
-    simp [y,h]
-  funext i
-  have h2 := h1 (Pi.single i 1)
-  by_cases hh : j = s
-  · simpa only [hh,ite_true,dotProduct_single,single_dotProduct,mul_one,one_mul] using h2
-  simpa only [ite_eq_right hh,Pi.zero_apply,single_dotProduct,one_mul] using h2
-
-namespace Volley
-variable {v : Volley p n I}
-
-private theorem mark_test {w : I → Bool} (hb : v.bounded w)
-    (t : Tagging p I) {a : Plan p n} {q} (hv : v.avoids a q)
-    (j : I) (z : Place p) (L : Finset (Label p.b)) (hl : L.card+14 ≤ q)
-    (ψ : Vec (AIdx p.g n))
-    (hh : inc z.1 (t j) → dotProduct ψ (baseV (v.par j)) = 0) :
-    ∃ x ∈ annih (sPin (v.frozen a t) z (v.obj j)),∀ k∈L,(labMat p n k)ᵀ *ᵥ x=
-      if k=v.sel j then ψ else 0 := by
-  classical
-  let i := v.obj j
-  obtain ⟨B,hB,hj,hc,hsel⟩ := hv i
-  let T := L∪v.marked i
-  have hT : T.card ≤ q :=
-    (Finset.card_union_le _ _).trans ((Nat.add_le_add_left (v.marked_card hb i) L.card).trans hl)
-  have hjj : j ∈ v.here i := by simp [here,i]
-  obtain ⟨x,hx,hX⟩ := protection_test (L:=T) (hB z)
-    (mem_union_right L (v.marked_mem j)) (hj _ hjj) hT ψ
-  refine ⟨x, ?_, fun k hk => hX k (mem_union_left _ hk)⟩
-  have he : sPin (v.frozen a t) z i ≤ LinearMap.ker (dotL x) := by
-    rw [v.sPin_frozen]
-    refine sup_le (fun y hy => (annih_mem ..).mp hx y hy) ?_
-    rintro y ⟨y,⟨u,rfl⟩,rfl⟩
-    rw [LinearMap.mem_ker]
-    rw [mulVecLin_apply,mulVecLin_apply,v.key_proj,map_sum]
-    refine Finset.sum_eq_zero fun k hk => ?_
-    rw [map_smul]
-    suffices h : dotL x (v.rayAt k.val)=0 by rw [h,smul_zero]
-    change dotProduct x (point p (v.sel k.val) (v.par k.val))= _
-    have hh' : k.val ∈ v.here i := (v.visitH_here ..).mp hk
-    have hx' : v.sel k.val ∈ T := mem_union_right _ (Finset.mem_image_of_mem _ hh')
-    rw [point,←labMat_act, ←dotProduct_transpose_mulVec,hX _ hx']
-    by_cases h : v.sel k.val=v.sel j
-    · have he' : k.val=j := hsel hh' hjj h
-      rw [ite_eq_left h,dotProduct_comm,he']
-      exact hh (he' ▸ k.property)
-    rw [ite_eq_right h,dotProduct_zero]
-  rw [annih_mem]
-  exact fun y hy => he hy
-
-private theorem ev_mput (s : Label p.b) (M : BaseMat p n) (x y : Ray p n) :
-    evmat (mput p s M) x y = evmat M ((labMat p n s)ᵀ *ᵥ x) ((labMat p n s)ᵀ *ᵥ y) := by
-  rw [← evmat_pull]
-  unfold mput pullM
-  rw [transpose_transpose]
-
-/-- Diagnostic for the two quotients by one affine ray. -/
-private theorem mark_diag {J : Type} [Fintype J] (Z : Mat (Option J) (Option J))
-    (hZ : Zᵀ = Z) (hd : ∀ i,Z i i=Z none i) (v : Vec (Option J))
-    (hv : v none=1) (he : ∀ φ, dotProduct φ v = 0 → ∀ ψ, dotProduct ψ v = 0 →
-      evmat Z φ ψ=0) :
-    Z = (Z none none) • vecMulVec v v := by
-  classical
-  let θ (i : Option J) := Pi.single i 1 + (Pi.single none (v i) : Vec (Option J))
-  have hθ (i) : dotProduct (θ i) v=0 := by
-    rw [show θ i=_+_ from rfl,add_dotProduct,single_dotProduct,single_dotProduct,
-      hv,one_mul,mul_one,char_two]
-  have hg (i j : Option J) :
-      Z i j + Z i none * v j + (v i*(Z none j)+v i * (Z none none * v j)) = 0 := by
-
-    have hh := he _ (hθ i) _ (hθ j)
-    simp only [θ,evmat,Matrix.mulVec_add,add_dotProduct,dotProduct_add, single_dotProduct,Matrix.mulVec_single,op_smul_eq_smul, one_mul,one_smul,Pi.smul_apply,smul_eq_mul,col_apply] at hh
-    simpa only [mul_comm,mul_left_comm,mul_assoc,add_comm,add_left_comm,add_assoc] using hh
-  have hf i : Z i none=Z none i := congr_fun (congr_fun hZ none) i
-  have h0 (i : Option J) : Z none i=Z none none * v i := by
-    have h := hg i i
-    rw [hd i,hf,mul_comm (Z none i),show v i*(Z none none*v i)=Z none none*v i from
-      (by rw [mul_left_comm,bit_sq])] at h
-    have h' : Z none i+Z none none*v i=0 := calc
-      _ = Z none i + ((v i * Z none i+v i * Z none i)+Z none none*v i) := by rw [char_two,zero_add]
-      _ = 0 := (by simpa only [add_assoc] using h)
-    exact add_right_cancel (h'.trans (char_two _).symm)
-  ext i j
-  change Z i j=Z none none*(v i*v j)
-  have h := hg i j
-  rw [h0 j,char_two,add_zero,hf,h0, mul_assoc] at h
-  exact add_right_cancel (h.trans (char_two _).symm)
-
-set_option maxHeartbeats 600000 in
-theorem mark_atom {w : I → Bool} (hb : v.bounded w)
-    (t : Tagging p I) {a : Plan p n} {q} (hv : v.avoids a q)
-    (j : I) (e : Comp p.g)
-    (L : Finset (Label p.b)) (hl : L.card+14≤q)
-    (Z : Label p.b → BaseMat p n)
-    (ht : ∀ s,s∉L → Z s=0) (hh : ∀ s∈L,(Z s)ᵀ=Z s ∧ ∀ i,Z s i i=Z s none i)
-    (hg : vanish (sPin (v.frozen a t) (e,true) (v.obj j))
-      (sPin (v.frozen a t) (e,false) (v.obj j)) (labelSum p L Z)) :
-    Z (v.sel j) = if inc e (t j) then
-      Z (v.sel j) none none • vecMulVec (baseV (v.par j)) (baseV (v.par j)) else 0 := by
-  classical
-  let s := v.sel j
-  change Z s = if inc e (t j) then _ else _
-  by_cases hs : s∈L
-  · let y := baseV (v.par j)
-    have he (φ ψ : Vec (AIdx p.g n)) (hφ : inc e (t j) → dotProduct φ y=0)
-        (hψ : inc e (t j) → dotProduct ψ y=0) :
-        evmat (Z s) φ ψ=0 := by
-      obtain ⟨x,hx,hX⟩ := mark_test hb t hv j (e,true) L hl φ hφ
-      obtain ⟨y,hy,hY⟩ := mark_test hb t hv j (e,false) L hl ψ hψ
-      have h := hg x hx y hy
-      unfold labelSum at h
-      rw [←mpair_outer,mpair_sum,Finset.sum_eq_single s] at h
-      · rwa [mpair_outer,ev_mput,hX _ hs,hY _ hs,ite_eq_left rfl,ite_eq_left rfl] at h
-      · intro i hi he; rw [mpair_outer,ev_mput,hX _ hi,hY _ hi,ite_eq_right he,ite_eq_right he]
-        simp [evmat]
-      simp [hs]
-    by_cases h : inc e (t j)
-    · rw [ite_eq_left h]
-      exact mark_diag _ (hh s hs).1 (hh s hs).2 y rfl (fun φ hφ ψ hψ => he φ ψ (fun _ => hφ)
-        (fun _ => hψ))
-    rw [ite_eq_right h]
-    apply evmat_ext
-    intro φ ψ
-    rw [he φ ψ (fun e => (h e).elim) (fun e => (h e).elim)]
-    simp [evmat]
-  change Z s = if inc e (t j) then Z s none none • _ else _
-  rw [ht s hs]
-  simp
-
-end Volley
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.FrozenProjections
+
+namespace OAI
+
+/-! # Response Annihilators -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Matrix Finset LinearMap Submodule Module
+open scoped BigOperators
+variable {p : Shape} {n : ℕ}
+variable {I : Type} [Fintype I]
+
+def dotL (x : Vec I) : Vec I →ₗ[F] F where
+  toFun y := dotProduct x y
+  map_add' u v := dotProduct_add x _ _
+  map_smul' b u := by
+    simp only [dotProduct,Pi.smul_apply,RingHom.id_apply,smul_eq_mul,mul_sum,mul_left_comm]
+
+theorem dotL_surj (x : Vec I →ₗ[F] F) : ∃ y : Vec I,x=dotL y := by
+  classical
+  let y (i:I) := x (Pi.single i 1)
+  refine ⟨y,LinearMap.ext fun v => ?_⟩
+  have he : x v=x (∑ i, Pi.single i (v i)) := by rw [Finset.univ_sum_single]
+  rw [he,map_sum]
+  change (∑ i,x (Pi.single i (v i)))=∑ i,y i*v i
+  refine Finset.sum_congr rfl fun i _ => ?_
+  rw [show Pi.single i (v i)=v i • (Pi.single i 1 : Vec I) from (by
+    funext j
+    by_cases h : j = i
+    · simp [h]
+    simp [Pi.single_eq_of_ne h]),
+    map_smul]
+  exact mul_comm _ _
+
+private theorem protection_test {S : Space (Ray p n)} {q} {E L : Finset (Label p.b)}
+    (h : protectedBy p S q E) {s} (hs : s∈L) (he : s∉E) (hl : L.card≤q)
+    (ψ : Vec (AIdx p.g n)) :
+    ∃ x ∈ annih S,∀ j∈L,(labMat p n j)ᵀ *ᵥ x= if j=s then ψ else 0 := by
+  classical
+  let P := S.subtype.coprod (labcomb p n L)
+  let Q := dotL ψ ∘ₗ LinearMap.proj s ∘ₗ (LinearMap.snd F S (LabVals p n))
+  obtain ⟨f,hf⟩ : ∃ f,f ∘ₗ P=Q := by
+    refine HadwigerCounterexample.mem_range_comp (show LinearMap.ker P≤LinearMap.ker Q from ?_)
+    rintro ⟨w,z⟩ hw
+    change w.val + labcomb p n L z=0 at hw
+    have hb : labcomb p n L z ∈ S := by
+      rw [show labcomb p n L z=w.val from add_left_cancel (hw.trans (char_two w.val).symm)]
+      exact w.property
+    change dotProduct ψ (z s)=0
+    rw [h L z hb hl s hs he,dotProduct_zero]
+  obtain ⟨x,rfl⟩ := dotL_surj f
+  refine ⟨x,?_,fun j hj => ?_⟩
+  · rw [annih_mem]; intro y hy
+    have hh := LinearMap.congr_fun hf (⟨y,hy⟩,0)
+    change dotProduct x (y+labcomb p n L 0)=dotProduct ψ 0 at hh
+    rw [map_zero,add_zero,dotProduct_zero] at hh
+    exact hh
+  have h1 (z : Vec (AIdx p.g n)) : dotProduct z ((labMat p n j)ᵀ *ᵥ x)=
+      if j=s then dotProduct ψ z else 0 := by
+    let y : LabVals p n := Pi.single j z
+    have hh := LinearMap.congr_fun hf (0,y)
+    change dotProduct x (0+labcomb p n L y)=dotProduct ψ (y s) at hh
+    have hh' : labcomb p n L y = putLab p n j z := by
+      rw [labcomb_eval,Finset.sum_eq_single j]
+      · simp [y]
+      · intro k _ hk; simp [y,Pi.single_eq_of_ne hk]
+      simp [hj]
+    rw [dotProduct_transpose_mulVec,labMat_act]
+    rw [zero_add,hh'] at hh
+    rw [hh]
+    by_cases h : j = s
+    · simp [y,h]
+    simp [y,h]
+  funext i
+  have h2 := h1 (Pi.single i 1)
+  by_cases hh : j = s
+  · simpa only [hh,ite_true,dotProduct_single,single_dotProduct,mul_one,one_mul] using h2
+  simpa only [ite_eq_right hh,Pi.zero_apply,single_dotProduct,one_mul] using h2
+
+namespace Volley
+variable {v : Volley p n I}
+
+private theorem mark_test {w : I → Bool} (hb : v.bounded w)
+    (t : Tagging p I) {a : Plan p n} {q} (hv : v.avoids a q)
+    (j : I) (z : Place p) (L : Finset (Label p.b)) (hl : L.card+14 ≤ q)
+    (ψ : Vec (AIdx p.g n))
+    (hh : inc z.1 (t j) → dotProduct ψ (baseV (v.par j)) = 0) :
+    ∃ x ∈ annih (sPin (v.frozen a t) z (v.obj j)),∀ k∈L,(labMat p n k)ᵀ *ᵥ x=
+      if k=v.sel j then ψ else 0 := by
+  classical
+  let i := v.obj j
+  obtain ⟨B,hB,hj,hc,hsel⟩ := hv i
+  let T := L∪v.marked i
+  have hT : T.card ≤ q :=
+    (Finset.card_union_le _ _).trans ((Nat.add_le_add_left (v.marked_card hb i) L.card).trans hl)
+  have hjj : j ∈ v.here i := by simp [here,i]
+  obtain ⟨x,hx,hX⟩ := protection_test (L:=T) (hB z)
+    (mem_union_right L (v.marked_mem j)) (hj _ hjj) hT ψ
+  refine ⟨x, ?_, fun k hk => hX k (mem_union_left _ hk)⟩
+  have he : sPin (v.frozen a t) z i ≤ LinearMap.ker (dotL x) := by
+    rw [v.sPin_frozen]
+    refine sup_le (fun y hy => (annih_mem ..).mp hx y hy) ?_
+    rintro y ⟨y,⟨u,rfl⟩,rfl⟩
+    rw [LinearMap.mem_ker]
+    rw [mulVecLin_apply,mulVecLin_apply,v.key_proj,map_sum]
+    refine Finset.sum_eq_zero fun k hk => ?_
+    rw [map_smul]
+    suffices h : dotL x (v.rayAt k.val)=0 by rw [h,smul_zero]
+    change dotProduct x (point p (v.sel k.val) (v.par k.val))= _
+    have hh' : k.val ∈ v.here i := (v.visitH_here ..).mp hk
+    have hx' : v.sel k.val ∈ T := mem_union_right _ (Finset.mem_image_of_mem _ hh')
+    rw [point,←labMat_act, ←dotProduct_transpose_mulVec,hX _ hx']
+    by_cases h : v.sel k.val=v.sel j
+    · have he' : k.val=j := hsel hh' hjj h
+      rw [ite_eq_left h,dotProduct_comm,he']
+      exact hh (he' ▸ k.property)
+    rw [ite_eq_right h,dotProduct_zero]
+  rw [annih_mem]
+  exact fun y hy => he hy
+
+private theorem ev_mput (s : Label p.b) (M : BaseMat p n) (x y : Ray p n) :
+    evmat (mput p s M) x y = evmat M ((labMat p n s)ᵀ *ᵥ x) ((labMat p n s)ᵀ *ᵥ y) := by
+  rw [← evmat_pull]
+  unfold mput pullM
+  rw [transpose_transpose]
+
+/-- Diagnostic for the two quotients by one affine ray. -/
+private theorem mark_diag {J : Type} [Fintype J] (Z : Mat (Option J) (Option J))
+    (hZ : Zᵀ = Z) (hd : ∀ i,Z i i=Z none i) (v : Vec (Option J))
+    (hv : v none=1) (he : ∀ φ, dotProduct φ v = 0 → ∀ ψ, dotProduct ψ v = 0 →
+      evmat Z φ ψ=0) :
+    Z = (Z none none) • vecMulVec v v := by
+  classical
+  let θ (i : Option J) := Pi.single i 1 + (Pi.single none (v i) : Vec (Option J))
+  have hθ (i) : dotProduct (θ i) v=0 := by
+    rw [show θ i=_+_ from rfl,add_dotProduct,single_dotProduct,single_dotProduct,
+      hv,one_mul,mul_one,char_two]
+  have hg (i j : Option J) :
+      Z i j + Z i none * v j + (v i*(Z none j)+v i * (Z none none * v j)) = 0 := by
+
+    have hh := he _ (hθ i) _ (hθ j)
+    simp only [θ,evmat,Matrix.mulVec_add,add_dotProduct,dotProduct_add, single_dotProduct,Matrix.mulVec_single,op_smul_eq_smul, one_mul,one_smul,Pi.smul_apply,smul_eq_mul,col_apply] at hh
+    simpa only [mul_comm,mul_left_comm,mul_assoc,add_comm,add_left_comm,add_assoc] using hh
+  have hf i : Z i none=Z none i := congr_fun (congr_fun hZ none) i
+  have h0 (i : Option J) : Z none i=Z none none * v i := by
+    have h := hg i i
+    rw [hd i,hf,mul_comm (Z none i),show v i*(Z none none*v i)=Z none none*v i from
+      (by rw [mul_left_comm,bit_sq])] at h
+    have h' : Z none i+Z none none*v i=0 := calc
+      _ = Z none i + ((v i * Z none i+v i * Z none i)+Z none none*v i) := by rw [char_two,zero_add]
+      _ = 0 := (by simpa only [add_assoc] using h)
+    exact add_right_cancel (h'.trans (char_two _).symm)
+  ext i j
+  change Z i j=Z none none*(v i*v j)
+  have h := hg i j
+  rw [h0 j,char_two,add_zero,hf,h0, mul_assoc] at h
+  exact add_right_cancel (h.trans (char_two _).symm)
+
+set_option maxHeartbeats 600000 in
+theorem mark_atom {w : I → Bool} (hb : v.bounded w)
+    (t : Tagging p I) {a : Plan p n} {q} (hv : v.avoids a q)
+    (j : I) (e : Comp p.g)
+    (L : Finset (Label p.b)) (hl : L.card+14≤q)
+    (Z : Label p.b → BaseMat p n)
+    (ht : ∀ s,s∉L → Z s=0) (hh : ∀ s∈L,(Z s)ᵀ=Z s ∧ ∀ i,Z s i i=Z s none i)
+    (hg : vanish (sPin (v.frozen a t) (e,true) (v.obj j))
+      (sPin (v.frozen a t) (e,false) (v.obj j)) (labelSum p L Z)) :
+    Z (v.sel j) = if inc e (t j) then
+      Z (v.sel j) none none • vecMulVec (baseV (v.par j)) (baseV (v.par j)) else 0 := by
+  classical
+  let s := v.sel j
+  change Z s = if inc e (t j) then _ else _
+  by_cases hs : s∈L
+  · let y := baseV (v.par j)
+    have he (φ ψ : Vec (AIdx p.g n)) (hφ : inc e (t j) → dotProduct φ y=0)
+        (hψ : inc e (t j) → dotProduct ψ y=0) :
+        evmat (Z s) φ ψ=0 := by
+      obtain ⟨x,hx,hX⟩ := mark_test hb t hv j (e,true) L hl φ hφ
+      obtain ⟨y,hy,hY⟩ := mark_test hb t hv j (e,false) L hl ψ hψ
+      have h := hg x hx y hy
+      unfold labelSum at h
+      rw [←mpair_outer,mpair_sum,Finset.sum_eq_single s] at h
+      · rwa [mpair_outer,ev_mput,hX _ hs,hY _ hs,ite_eq_left rfl,ite_eq_left rfl] at h
+      · intro i hi he; rw [mpair_outer,ev_mput,hX _ hi,hY _ hi,ite_eq_right he,ite_eq_right he]
+        simp [evmat]
+      simp [hs]
+    by_cases h : inc e (t j)
+    · rw [ite_eq_left h]
+      exact mark_diag _ (hh s hs).1 (hh s hs).2 y rfl (fun φ hφ ψ hψ => he φ ψ (fun _ => hφ)
+        (fun _ => hψ))
+    rw [ite_eq_right h]
+    apply evmat_ext
+    intro φ ψ
+    rw [he φ ψ (fun e => (h e).elim) (fun e => (h e).elim)]
+    simp [evmat]
+  change Z s = if inc e (t j) then Z s none none • _ else _
+  rw [ht s hs]
+  simp
+
+end Volley
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/ResponseSolvability.lean

@@ -1,188 +1,188 @@
-import OAI.Combinatorics.HadwigerCounterexample.ResidualCutPairs
-
-namespace OAI
-
-/-! # Response Solvability -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Matrix LinearMap Module Finset Submodule
-open scoped BigOperators
-variable {p : Shape} {n N : ℕ} {I : Type} [Fintype I]
-
-abbrev Individual (p : Shape) (n : ℕ) := Bool → Profile p n
-abbrev OnForms (p : Shape) (n : ℕ) := Bool → (Profile p n →ₗ[F] F)
-abbrev ReqF (p : Shape) (n : ℕ) := Module.Dual F (Xpair p n)
-
-def combineF (p : Shape) {n} : OnForms p n →ₗ[F] ReqF p n where
-  toFun f := ∑ i : Bool, f i ∘ₗ (Xspace p n).subtype ∘ₗ LinearMap.proj i
-  map_add' f g := LinearMap.ext fun x => by
-    simp only [LinearMap.sum_apply,LinearMap.comp_apply,Pi.add_apply,LinearMap.add_apply,
-      Finset.sum_add_distrib]
-  map_smul' a f := LinearMap.ext fun x => by
-    simp only [LinearMap.sum_apply,LinearMap.comp_apply,Pi.smul_apply,LinearMap.smul_apply,
-      RingHom.id_apply,smul_eq_mul,mul_sum]
-
-theorem combineF_val (f : OnForms p n) (x : Xpair p n) :
-    combineF p f x= ∑ i, f i (x i).val := by
-  simp only [combineF,LinearMap.coe_mk,AddHom.coe_mk,LinearMap.sum_apply]; rfl
-
-theorem combineF_single (f : OnForms p n) (i : Bool) (x : Xspace p n) :
-    combineF p f (Pi.single i x)=f i x.val := by
-  rw [combineF_val,Finset.sum_eq_single i]
-  · rw [Pi.single_eq_same]
-  · intro j _ hj; simp [hj]
-  simp
-
-theorem combineF_same (f g : OnForms p n) : combineF p f=combineF p g ↔
-    ∀ i,∀ x ∈ Xspace p n,f i x=g i x := by
-  constructor
-  · intro h i x hx
-    exact (combineF_single f i ⟨x,hx⟩).symm.trans (h ▸ combineF_single g i ⟨x,hx⟩)
-  intro h
-  apply LinearMap.ext; intro x
-  rw [combineF_val,combineF_val]
-  exact Finset.sum_congr rfl fun i _ => h i _ (x i).property
-
-def obsPair (p : Shape) {n} : PureForms p n →ₗ[F] ReqF p n :=
-  react p 0 ∘ₗ LinearMap.inr F (ChanOut p n) (PureForms p n)
-
-theorem obsPair_val (A : PureForms p n) (x : Xpair p n) :
-    obsPair p A x=∑ i,mpair (A i) (purePair p n x i) := by
-  change ∑ i : Comp p.g, _ = _
-  refine Finset.sum_congr rfl fun i _ => ?_
-  change mpair ((chanDeriv p (n:=n) 0 0+A) _) _=_
-  simp only [chanDeriv,chanInner,Pi.add_apply,Pi.zero_apply,Matrix.transpose_zero,Matrix.zero_mul,
-    zero_add]
-
-/-- Restrict pure form to individual diagonal blocks. -/
-def eachF (p : Shape) {n} :
-    PureForms p n →ₗ[F] Individual p n where
-  toFun P i e := pullM (IP p n i) (IP p n i) (P e)
-  map_add' P Q := by ext; simp only [Pi.add_apply,map_add]
-  map_smul' a P := by ext; simp only [Pi.smul_apply,map_smul,RingHom.id_apply]
-
-/-- Extend the individual forms by zero outside respective blocks, then add. -/
-def sumF (p : Shape) {n} : Individual p n → PureForms p n :=
-  fun A e => ∑ i,liftM (IP p n i) (IP p n i) (A i e)
-theorem each_sumF (A : Individual p n) : eachF p (sumF p A)=A := by
-  classical
-  funext i e
-  change pullM _ _ (∑ j,_) = _
-  rw [map_sum,Finset.sum_eq_single i]
-  · unfold pullM; rw [liftM_comp,IP_self]
-    simp [liftM_def]
-  · intro j _ hj
-    unfold pullM
-    rw [liftM_comp,IP_cross (Ne.symm hj)]
-    simp [liftM_def]
-  simp
-
-def repF (p : Shape) {n} (A : Individual p n) : OnForms p n :=
-  fun i => ∑ e : Comp p.g, mpair (A i e) ∘ₗ LinearMap.proj e
-
-theorem repF_rep (A : Individual p n) (i) :
-    Represents (repF p A i) (A i) := by
-  intro x
-  simp only [repF,LinearMap.sum_apply]; rfl
-
-theorem obsPair_each (P : PureForms p n) :
-    obsPair p P=combineF p (repF p (eachF p P)) := by
-  apply LinearMap.ext
-  intro x
-  rw [obsPair_val,combineF_val]
-  simp_rw [purePair,Finset.sum_apply,map_sum]
-  rw [Finset.sum_comm]
-  refine Finset.sum_congr rfl fun i _ => ?_
-  rw [repF_rep]
-  refine Finset.sum_congr rfl fun e _ => ?_
-  rw [mpair_liftM]; rfl
-
-theorem obsPair_chan (B : Cross p n) (j : Bool) :
-    obsPair p (chanInner p (channelOut p B j) (channelOut p B j))=
-    combineF p (fun i => contract p B i j) := by
-  apply LinearMap.ext; intro x
-  rw [obsPair_val,combineF_val]
-  simp_rw [purePair,Finset.sum_apply,map_sum]
-  rw [Finset.sum_comm]; rfl
-
-theorem each_chan_val (B C : ChanOut p n) (i) (e : Comp p.g) :
-    eachF p (chanInner p B C) i e=(B (e,true) * IP p n i)ᵀ * (C (e,false)*IP p n i) := by
-  change pullM _ _ _=_
-  simp only [pullM_def,chanInner,transpose_mul,Matrix.mul_assoc]
-
-theorem obsPair_chan_change (B C : ChanOut p n) :
-    obsPair p (chanInner p (B+C) (B+C))=
-    obsPair p (chanInner p B B)+ obsPair p (chanDeriv p B C) + obsPair p (chanInner p C C) := by
-  rw [←map_add,←map_add]
-  congr 1
-  unfold chanInner chanDeriv
-  funext i
-  simp only [chanInner,Pi.add_apply,Matrix.transpose_add,Matrix.add_mul,Matrix.mul_add,add_assoc]
-  ac_rfl
-
-theorem react_obsPair (B C : ChanOut p n) (D : PureForms p n) :
-    react p B (C,D)=obsPair p (chanDeriv p B C) + obsPair p D := by
-  rw [←map_add]
-  exact LinearMap.ext (fun x => (obsPair_val _ x).symm)
-
-namespace Volley
-variable (v w : Volley p n I)
-
-def demand (t : Tagging p I) (m : Mixer p n) (j : Bool) : OnForms p n :=
-  fun i => grad m (v.sumAt t w.obj i j)
-
-theorem realize_linear {t : Tagging p I} (m : Mixer p n)
-    (x y : UnitType p n N) (a b : Plan p n) (t' B : Cross p n)
-    (hb : v.bounded w.obj) (ht : v.legal t)
-    (q R : ℕ) (hv : v.avoids a q) (hj : 6*R+4≤p.j)
-    (hr : 2*planRank a+28≤R) (hq : R+14≤q)
-    (hB : fitsTable a b B t') (hT : tableInj a b t')
-    (hf : rowAgree (v.frozen a t) B (actual p x y))
-    (hR : v.scalarRecipe w t m x a t') (hk : v.keys t x=w.keys t y)
-    (hL : ∀ i, frameLaw m (onSide y i))
-    (hS : v.attackGrad w t m y) (j : Bool) :
-    ∃ C∈deltaSpace p (v.frozen a t) b j,
-    ∃ P∈pureSpace p (v.frozen a t),
-      obsPair p (chanInner p (channelOut p B j) (channelOut p B j))+
-      obsPair p (chanDeriv p (channelOut p B j) C) + obsPair p P=
-        combineF p (v.demand w t m j) := by
-  classical
-  let G := v.demand w t m j
-  let K : OnForms p n := fun i => contract p B i j
-  let CC := channelOut p B j
-  have h1 (i : I) : G (v.obj i) (v.atomAt t i) = K (v.obj i) (v.atomAt t i) := by
-    change grad m (v.sumAt t w.obj (v.obj i) j) _ = contract p B _ _ _
-    rw [frozen_contract_key v t hf,contract_actual,LinearMap.comp_apply,hS i j,
-      v.atom_share w t x y hk]
-    by_cases h : j=w.obj i
-    · rw [ite_eq_left h,h,ufun_self (hL _)]
-    have hh : (! (w.obj i))=j := by cases j <;> cases e : w.obj i <;> simp_all
-    rw [ite_eq_right h, innerP, hh]; rfl
-  have hg (z : Xpair p n) (h : orth p CC (v.frozen a t) b j z) :
-      combineF p (G-K) z=0 := by
-    obtain ⟨c,z,rfl,ho,hy⟩ := split_orth hb ht h hv hj hr hq
-    have he (i : Bool) := clean_effective t hb hv hq B z ho (fits_inj hB hT) i (hy i)
-    rw [map_add,map_sum]
-    have h2 : combineF p (G-K) z = 0 := by
-      rw [combineF_val]
-      refine Finset.sum_eq_zero fun i _ => ?_
-      rw [Pi.sub_apply,LinearMap.sub_apply]
-      exact sub_eq_zero.mpr ((hR.gradient i j _ (he i)).trans (fits_contract hB i j _ (he i)).symm)
-    rw [h2,zero_add]
-    refine Finset.sum_eq_zero fun i _ => ?_
-    rw [map_smul,strike,combineF_single,Pi.sub_apply,LinearMap.sub_apply,
-      h1 i,sub_self,smul_zero]
-
-  obtain ⟨C,hC,P,hP,h⟩ := solve_by_dual _ hg
-  rw [react_obsPair,map_sub] at h
-  rw [obsPair_chan]
-  refine ⟨C,hC,P,hP,?_⟩
-  rw [add_assoc,h,add_sub_cancel]
-end Volley
-
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.ResidualCutPairs
+
+namespace OAI
+
+/-! # Response Solvability -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Matrix LinearMap Module Finset Submodule
+open scoped BigOperators
+variable {p : Shape} {n N : ℕ} {I : Type} [Fintype I]
+
+abbrev Individual (p : Shape) (n : ℕ) := Bool → Profile p n
+abbrev OnForms (p : Shape) (n : ℕ) := Bool → (Profile p n →ₗ[F] F)
+abbrev ReqF (p : Shape) (n : ℕ) := Module.Dual F (Xpair p n)
+
+def combineF (p : Shape) {n} : OnForms p n →ₗ[F] ReqF p n where
+  toFun f := ∑ i : Bool, f i ∘ₗ (Xspace p n).subtype ∘ₗ LinearMap.proj i
+  map_add' f g := LinearMap.ext fun x => by
+    simp only [LinearMap.sum_apply,LinearMap.comp_apply,Pi.add_apply,LinearMap.add_apply,
+      Finset.sum_add_distrib]
+  map_smul' a f := LinearMap.ext fun x => by
+    simp only [LinearMap.sum_apply,LinearMap.comp_apply,Pi.smul_apply,LinearMap.smul_apply,
+      RingHom.id_apply,smul_eq_mul,mul_sum]
+
+theorem combineF_val (f : OnForms p n) (x : Xpair p n) :
+    combineF p f x= ∑ i, f i (x i).val := by
+  simp only [combineF,LinearMap.coe_mk,AddHom.coe_mk,LinearMap.sum_apply]; rfl
+
+theorem combineF_single (f : OnForms p n) (i : Bool) (x : Xspace p n) :
+    combineF p f (Pi.single i x)=f i x.val := by
+  rw [combineF_val,Finset.sum_eq_single i]
+  · rw [Pi.single_eq_same]
+  · intro j _ hj; simp [hj]
+  simp
+
+theorem combineF_same (f g : OnForms p n) : combineF p f=combineF p g ↔
+    ∀ i,∀ x ∈ Xspace p n,f i x=g i x := by
+  constructor
+  · intro h i x hx
+    exact (combineF_single f i ⟨x,hx⟩).symm.trans (h ▸ combineF_single g i ⟨x,hx⟩)
+  intro h
+  apply LinearMap.ext; intro x
+  rw [combineF_val,combineF_val]
+  exact Finset.sum_congr rfl fun i _ => h i _ (x i).property
+
+def obsPair (p : Shape) {n} : PureForms p n →ₗ[F] ReqF p n :=
+  react p 0 ∘ₗ LinearMap.inr F (ChanOut p n) (PureForms p n)
+
+theorem obsPair_val (A : PureForms p n) (x : Xpair p n) :
+    obsPair p A x=∑ i,mpair (A i) (purePair p n x i) := by
+  change ∑ i : Comp p.g, _ = _
+  refine Finset.sum_congr rfl fun i _ => ?_
+  change mpair ((chanDeriv p (n:=n) 0 0+A) _) _=_
+  simp only [chanDeriv,chanInner,Pi.add_apply,Pi.zero_apply,Matrix.transpose_zero,Matrix.zero_mul,
+    zero_add]
+
+/-- Restrict pure form to individual diagonal blocks. -/
+def eachF (p : Shape) {n} :
+    PureForms p n →ₗ[F] Individual p n where
+  toFun P i e := pullM (IP p n i) (IP p n i) (P e)
+  map_add' P Q := by ext; simp only [Pi.add_apply,map_add]
+  map_smul' a P := by ext; simp only [Pi.smul_apply,map_smul,RingHom.id_apply]
+
+/-- Extend the individual forms by zero outside respective blocks, then add. -/
+def sumF (p : Shape) {n} : Individual p n → PureForms p n :=
+  fun A e => ∑ i,liftM (IP p n i) (IP p n i) (A i e)
+theorem each_sumF (A : Individual p n) : eachF p (sumF p A)=A := by
+  classical
+  funext i e
+  change pullM _ _ (∑ j,_) = _
+  rw [map_sum,Finset.sum_eq_single i]
+  · unfold pullM; rw [liftM_comp,IP_self]
+    simp [liftM_def]
+  · intro j _ hj
+    unfold pullM
+    rw [liftM_comp,IP_cross (Ne.symm hj)]
+    simp [liftM_def]
+  simp
+
+def repF (p : Shape) {n} (A : Individual p n) : OnForms p n :=
+  fun i => ∑ e : Comp p.g, mpair (A i e) ∘ₗ LinearMap.proj e
+
+theorem repF_rep (A : Individual p n) (i) :
+    Represents (repF p A i) (A i) := by
+  intro x
+  simp only [repF,LinearMap.sum_apply]; rfl
+
+theorem obsPair_each (P : PureForms p n) :
+    obsPair p P=combineF p (repF p (eachF p P)) := by
+  apply LinearMap.ext
+  intro x
+  rw [obsPair_val,combineF_val]
+  simp_rw [purePair,Finset.sum_apply,map_sum]
+  rw [Finset.sum_comm]
+  refine Finset.sum_congr rfl fun i _ => ?_
+  rw [repF_rep]
+  refine Finset.sum_congr rfl fun e _ => ?_
+  rw [mpair_liftM]; rfl
+
+theorem obsPair_chan (B : Cross p n) (j : Bool) :
+    obsPair p (chanInner p (channelOut p B j) (channelOut p B j))=
+    combineF p (fun i => contract p B i j) := by
+  apply LinearMap.ext; intro x
+  rw [obsPair_val,combineF_val]
+  simp_rw [purePair,Finset.sum_apply,map_sum]
+  rw [Finset.sum_comm]; rfl
+
+theorem each_chan_val (B C : ChanOut p n) (i) (e : Comp p.g) :
+    eachF p (chanInner p B C) i e=(B (e,true) * IP p n i)ᵀ * (C (e,false)*IP p n i) := by
+  change pullM _ _ _=_
+  simp only [pullM_def,chanInner,transpose_mul,Matrix.mul_assoc]
+
+theorem obsPair_chan_change (B C : ChanOut p n) :
+    obsPair p (chanInner p (B+C) (B+C))=
+    obsPair p (chanInner p B B)+ obsPair p (chanDeriv p B C) + obsPair p (chanInner p C C) := by
+  rw [←map_add,←map_add]
+  congr 1
+  unfold chanInner chanDeriv
+  funext i
+  simp only [chanInner,Pi.add_apply,Matrix.transpose_add,Matrix.add_mul,Matrix.mul_add,add_assoc]
+  ac_rfl
+
+theorem react_obsPair (B C : ChanOut p n) (D : PureForms p n) :
+    react p B (C,D)=obsPair p (chanDeriv p B C) + obsPair p D := by
+  rw [←map_add]
+  exact LinearMap.ext (fun x => (obsPair_val _ x).symm)
+
+namespace Volley
+variable (v w : Volley p n I)
+
+def demand (t : Tagging p I) (m : Mixer p n) (j : Bool) : OnForms p n :=
+  fun i => grad m (v.sumAt t w.obj i j)
+
+theorem realize_linear {t : Tagging p I} (m : Mixer p n)
+    (x y : UnitType p n N) (a b : Plan p n) (t' B : Cross p n)
+    (hb : v.bounded w.obj) (ht : v.legal t)
+    (q R : ℕ) (hv : v.avoids a q) (hj : 6*R+4≤p.j)
+    (hr : 2*planRank a+28≤R) (hq : R+14≤q)
+    (hB : fitsTable a b B t') (hT : tableInj a b t')
+    (hf : rowAgree (v.frozen a t) B (actual p x y))
+    (hR : v.scalarRecipe w t m x a t') (hk : v.keys t x=w.keys t y)
+    (hL : ∀ i, frameLaw m (onSide y i))
+    (hS : v.attackGrad w t m y) (j : Bool) :
+    ∃ C∈deltaSpace p (v.frozen a t) b j,
+    ∃ P∈pureSpace p (v.frozen a t),
+      obsPair p (chanInner p (channelOut p B j) (channelOut p B j))+
+      obsPair p (chanDeriv p (channelOut p B j) C) + obsPair p P=
+        combineF p (v.demand w t m j) := by
+  classical
+  let G := v.demand w t m j
+  let K : OnForms p n := fun i => contract p B i j
+  let CC := channelOut p B j
+  have h1 (i : I) : G (v.obj i) (v.atomAt t i) = K (v.obj i) (v.atomAt t i) := by
+    change grad m (v.sumAt t w.obj (v.obj i) j) _ = contract p B _ _ _
+    rw [frozen_contract_key v t hf,contract_actual,LinearMap.comp_apply,hS i j,
+      v.atom_share w t x y hk]
+    by_cases h : j=w.obj i
+    · rw [ite_eq_left h,h,ufun_self (hL _)]
+    have hh : (! (w.obj i))=j := by cases j <;> cases e : w.obj i <;> simp_all
+    rw [ite_eq_right h, innerP, hh]; rfl
+  have hg (z : Xpair p n) (h : orth p CC (v.frozen a t) b j z) :
+      combineF p (G-K) z=0 := by
+    obtain ⟨c,z,rfl,ho,hy⟩ := split_orth hb ht h hv hj hr hq
+    have he (i : Bool) := clean_effective t hb hv hq B z ho (fits_inj hB hT) i (hy i)
+    rw [map_add,map_sum]
+    have h2 : combineF p (G-K) z = 0 := by
+      rw [combineF_val]
+      refine Finset.sum_eq_zero fun i _ => ?_
+      rw [Pi.sub_apply,LinearMap.sub_apply]
+      exact sub_eq_zero.mpr ((hR.gradient i j _ (he i)).trans (fits_contract hB i j _ (he i)).symm)
+    rw [h2,zero_add]
+    refine Finset.sum_eq_zero fun i _ => ?_
+    rw [map_smul,strike,combineF_single,Pi.sub_apply,LinearMap.sub_apply,
+      h1 i,sub_self,smul_zero]
+
+  obtain ⟨C,hC,P,hP,h⟩ := solve_by_dual _ hg
+  rw [react_obsPair,map_sub] at h
+  rw [obsPair_chan]
+  refine ⟨C,hC,P,hP,?_⟩
+  rw [add_assoc,h,add_sub_cancel]
+end Volley
+
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/RestrictedComparisonLaws.lean

@@ -1,101 +1,101 @@
-import OAI.Combinatorics.HadwigerCounterexample.ConditionalFlags
-
-namespace OAI
-
-/-! # Restricted Comparison Laws -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Finset Real
-open scoped BigOperators
-variable {A B C : Type} [Fintype A] [Fintype B] [Fintype C]
-
-def hung (Q : Wgt B→Prop) (P : B→Prop) (w : Wgt B) :=
-  ∃ v : Wgt B, Q v ∧ w=subW v P
-def smallSet (Q : Wgt B→Prop) (q : Wgt B) (δ η : ℝ) :=
-  ∀ p,Q p → ∀ P : B→ Prop, pr q P ≤ δ → pr p P ≤ η
-def rosterTail (Q : Wgt B→Prop) (q : Wgt B) (R η : ℝ) :=
-  ∀ p,Q p → pr p (fun x => R≤density q p x)≤η
-
-theorem hung_roster (Q : Wgt B → Prop) (P : B→Prop) (r : ℕ) (ε : ℝ) :
-    roster Q r ε → roster (hung Q P) r ε := by
-  classical
-  rintro ⟨t,ht,w,hw⟩
-  refine ⟨t,ht,fun i => subW (w i) P,?_⟩
-  rintro p ⟨v,h,rfl⟩
-  obtain ⟨i,hi⟩ := hw v h
-  refine ⟨i,le_trans ?_ hi⟩
-  unfold varOne subW
-  refine sum_le_sum fun x _ => ?_
-  by_cases h : P x <;> simp [ind,h]
-
-variable [Nonempty B]
-
-theorem hung_small (Q : Wgt B→Prop) (P : B→Prop) (δ η : ℝ)
-    (hq : smallSet Q unif δ η) : smallSet (hung Q P) (unifOn P) δ η := by
-  classical
-  rintro p ⟨v,hv,rfl⟩ S hs
-  rw [pr_sub]
-  refine hq v hv (fun x => P x∧ S x) ?_
-  rw [pr_of_on unif_law.nz,on_unif]
-  refine le_trans ?_ hs
-  have ht := (pr_le_tot (α:=B) (p:=P) unif_law.nz).trans unif_law.total.le
-  exact (mul_le_mul_of_nonneg_right ht (pr_nonneg (unifOn_sub _).nz)).trans_eq (one_mul _)
-
-omit [Nonempty B] in
-theorem density_hung (P : B→Prop) (w : Wgt B) (hw : carried w P) :
-    ∀ i, unifOn P i * density (unifOn P) w i=w i := by
-  classical
-  intro i
-  by_cases h : w i =0
-  · simp only [density,h,zero_div,mul_zero]
-  have ht : P i := not_not.mp fun hi => h (hw i hi)
-  have hn := unifOn_law (p:=P) ⟨i,ht⟩
-  have he : unifOn P i≠0 := by
-    rw [unifOn_val,ind_one ht]
-    have hh : nbr P ≠0 := by
-      have he := weight_le_tot (fun j => ind_nonneg (P j)) i
-      rw [ind_one ht] at he
-      exact (lt_of_lt_of_le zero_lt_one he).ne'
-    exact div_ne_zero one_ne_zero hh
-  unfold density; field_simp
-
-theorem hung_tail (Q : Wgt B→Prop) (P : B→ Prop)
-    (h : ∀ p,Q p → SubLaw p) (δ η : ℝ)
-    (hδ : 0<δ) (hh : smallSet Q unif δ η) :
-    rosterTail (hung Q P) (unifOn P) δ⁻¹ η := by
-  intro p hp
-  apply hung_small Q P δ η hh p hp
-  obtain ⟨w,hw,rfl⟩ := hp
-  let q := unifOn P
-  let v := subW w P
-  let f := density q v
-  have hq := unifOn_sub P
-  have hv := subLaw_sub (h w hw) P
-  have hh :
-      avg q f = tot v := Finset.sum_congr rfl fun i _ => density_hung P v
-        (subW_carried w P) i
-  have hz := le_avg_markov hq.nz (fun i => div_nonneg (hv.nz i) (hq.nz i)) δ⁻¹
-  change δ⁻¹*pr q _≤avg q f at hz
-  apply le_of_mul_le_mul_left _ (inv_pos_of_pos hδ)
-  rw [inv_mul_cancel₀ hδ.ne']
-  exact (hz.trans_eq hh).trans hv.total
-
-omit [Nonempty B] in
-theorem hung_var (P : B→Prop) (p q : Wgt B) (hp : carried p P) (hq : carried q P) :
-    avg (unifOn P) (fun i => |density (unifOn P) p i-density (unifOn P) q i|)=varOne p q := by
-  classical
-  unfold avg varOne
-  refine sum_congr rfl fun i _ => ?_
-  rw [←abs_of_nonneg ((unifOn_sub P).nz i)]
-  have he := density_hung P p hp i
-
-  simp_rw [abs_of_nonneg ((unifOn_sub P).nz i)]
-  calc _ = |unifOn P i * (density (unifOn P) p i - density (unifOn P) q i)| :=
-                 by rw [abs_mul,abs_of_nonneg ((unifOn_sub P).nz i)]
-       _ = _ := by rw [mul_sub,he,density_hung P q hq i]
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.ConditionalFlags
+
+namespace OAI
+
+/-! # Restricted Comparison Laws -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Finset Real
+open scoped BigOperators
+variable {A B C : Type} [Fintype A] [Fintype B] [Fintype C]
+
+def hung (Q : Wgt B→Prop) (P : B→Prop) (w : Wgt B) :=
+  ∃ v : Wgt B, Q v ∧ w=subW v P
+def smallSet (Q : Wgt B→Prop) (q : Wgt B) (δ η : ℝ) :=
+  ∀ p,Q p → ∀ P : B→ Prop, pr q P ≤ δ → pr p P ≤ η
+def rosterTail (Q : Wgt B→Prop) (q : Wgt B) (R η : ℝ) :=
+  ∀ p,Q p → pr p (fun x => R≤density q p x)≤η
+
+theorem hung_roster (Q : Wgt B → Prop) (P : B→Prop) (r : ℕ) (ε : ℝ) :
+    roster Q r ε → roster (hung Q P) r ε := by
+  classical
+  rintro ⟨t,ht,w,hw⟩
+  refine ⟨t,ht,fun i => subW (w i) P,?_⟩
+  rintro p ⟨v,h,rfl⟩
+  obtain ⟨i,hi⟩ := hw v h
+  refine ⟨i,le_trans ?_ hi⟩
+  unfold varOne subW
+  refine sum_le_sum fun x _ => ?_
+  by_cases h : P x <;> simp [ind,h]
+
+variable [Nonempty B]
+
+theorem hung_small (Q : Wgt B→Prop) (P : B→Prop) (δ η : ℝ)
+    (hq : smallSet Q unif δ η) : smallSet (hung Q P) (unifOn P) δ η := by
+  classical
+  rintro p ⟨v,hv,rfl⟩ S hs
+  rw [pr_sub]
+  refine hq v hv (fun x => P x∧ S x) ?_
+  rw [pr_of_on unif_law.nz,on_unif]
+  refine le_trans ?_ hs
+  have ht := (pr_le_tot (α:=B) (p:=P) unif_law.nz).trans unif_law.total.le
+  exact (mul_le_mul_of_nonneg_right ht (pr_nonneg (unifOn_sub _).nz)).trans_eq (one_mul _)
+
+omit [Nonempty B] in
+theorem density_hung (P : B→Prop) (w : Wgt B) (hw : carried w P) :
+    ∀ i, unifOn P i * density (unifOn P) w i=w i := by
+  classical
+  intro i
+  by_cases h : w i =0
+  · simp only [density,h,zero_div,mul_zero]
+  have ht : P i := not_not.mp fun hi => h (hw i hi)
+  have hn := unifOn_law (p:=P) ⟨i,ht⟩
+  have he : unifOn P i≠0 := by
+    rw [unifOn_val,ind_one ht]
+    have hh : nbr P ≠0 := by
+      have he := weight_le_tot (fun j => ind_nonneg (P j)) i
+      rw [ind_one ht] at he
+      exact (lt_of_lt_of_le zero_lt_one he).ne'
+    exact div_ne_zero one_ne_zero hh
+  unfold density; field_simp
+
+theorem hung_tail (Q : Wgt B→Prop) (P : B→ Prop)
+    (h : ∀ p,Q p → SubLaw p) (δ η : ℝ)
+    (hδ : 0<δ) (hh : smallSet Q unif δ η) :
+    rosterTail (hung Q P) (unifOn P) δ⁻¹ η := by
+  intro p hp
+  apply hung_small Q P δ η hh p hp
+  obtain ⟨w,hw,rfl⟩ := hp
+  let q := unifOn P
+  let v := subW w P
+  let f := density q v
+  have hq := unifOn_sub P
+  have hv := subLaw_sub (h w hw) P
+  have hh :
+      avg q f = tot v := Finset.sum_congr rfl fun i _ => density_hung P v
+        (subW_carried w P) i
+  have hz := le_avg_markov hq.nz (fun i => div_nonneg (hv.nz i) (hq.nz i)) δ⁻¹
+  change δ⁻¹*pr q _≤avg q f at hz
+  apply le_of_mul_le_mul_left _ (inv_pos_of_pos hδ)
+  rw [inv_mul_cancel₀ hδ.ne']
+  exact (hz.trans_eq hh).trans hv.total
+
+omit [Nonempty B] in
+theorem hung_var (P : B→Prop) (p q : Wgt B) (hp : carried p P) (hq : carried q P) :
+    avg (unifOn P) (fun i => |density (unifOn P) p i-density (unifOn P) q i|)=varOne p q := by
+  classical
+  unfold avg varOne
+  refine sum_congr rfl fun i _ => ?_
+  rw [←abs_of_nonneg ((unifOn_sub P).nz i)]
+  have he := density_hung P p hp i
+
+  simp_rw [abs_of_nonneg ((unifOn_sub P).nz i)]
+  calc _ = |unifOn P i * (density (unifOn P) p i - density (unifOn P) q i)| :=
+                 by rw [abs_mul,abs_of_nonneg ((unifOn_sub P).nz i)]
+       _ = _ := by rw [mul_sub,he,density_hung P q hq i]
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/RoundedRefinements.lean

@@ -1,156 +1,156 @@
-import OAI.Combinatorics.HadwigerCounterexample.RefinementEnergy
-
-namespace OAI
-
-/-! # Rounded Refinements -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Finset Filter Matrix Real
-open scoped BigOperators
-variable {A B C D : Type} [Fintype A] [Fintype B] [Fintype C] [Fintype D]
-
-set_option maxHeartbeats 900000 in
-theorem divide_fit (q : Wgt B) (hq : IsLaw q) (f : B→C) (P : B→Prop)
-    (δ γ : ℝ) (hγ : 0<γ) (hz : 2*γ ≤ δ) (h : stamina (mapW q f) δ) :
-    ∃ F : B→C×Bool, f=Prod.fst∘F ∧ stamina (mapW q F) γ ∧
-    pr q (fun i => ¬(P i ↔ (F i).2))≤num (C×Bool)*γ := by
-  classical
-  let g (i : B) : C × Bool := (f i,decide (P i))
-  let Q := mapW q g
-  have hQ := mapW_law hq g
-  have hf : f=Prod.fst∘g := rfl
-  have hi (i) : mapW q f i=Q (i,true)+Q (i,false) := by
-    have hs : mapW q f=mapW Q Prod.fst := hf ▸ Eq.symm (map_nested g Prod.fst)
-    rw [hs]
-    simp only [mapW,pr,avg,Fintype.sum_prod_type,Fintype.sum_bool]; simp [ind,Finset.sum_add_distrib]
-  let s (j:C×Bool) : Bool := if Q (j.1,true) < γ then false else
-    if Q (j.1,false) < γ then true else j.2
-  let F (j : C × Bool) : C × Bool := (j.1,s j)
-  refine ⟨F ∘ g,rfl,?_,?_⟩
-  · rintro ⟨i,b⟩ h'
-    have hb :
-        mapW Q F (i,b)=Q (i,true)*ind (s (i,true)=b)+
-          Q (i,false)*ind (s (i,false)=b) := by
-      unfold mapW pr avg
-      rw [Fintype.sum_prod_type, sum_eq_single i]
-      · rw [Fintype.sum_bool]; simp [ind,F]
-      · intro j _ hj; rw [Fintype.sum_bool]; simp [ind,F,hj]
-      simp
-    rw [←map_nested,hb] at h' ⊢
-    by_cases hx : Q (i,true)<γ
-    · cases b
-      · simp only [s,hx,ite_true,ind_true,mul_one] at *
-        rw [←hi] at *
-        exact le_trans (by linarith only [hz,hγ]) (h i h')
-      simp [s,hx,ind] at h'
-    by_cases hy : Q (i,false)<γ
-    · cases b
-      · simp [s,hx,hy,ind] at h'
-      simp only [s,hx,hy,ite_true,ite_false,ind_true,mul_one] at *
-      rw [←hi] at *
-      exact le_trans (by linarith only [hz,hγ]) (h i h')
-    cases b
-    · simpa [s,hx,hy,ind] using (le_of_not_gt hy)
-    simpa [s,hx,hy,ind] using (le_of_not_gt hx)
-  let R (i : C×Bool) := i.2≠s i
-  have he j : (¬ (P j ↔ (F (g j)).2)) ↔ R (g j) := by
-    change (¬ (P j ↔ s (g j)=true)) ↔ decide (P j)≠s (g j)
-    cases s (g j) <;> simp
-  have h1 (j : C×Bool) : R j→ Q j≤γ := by
-    intro hj
-    rcases j with ⟨i,b⟩
-    by_cases hx : Q (i,true)<γ
-    · cases b
-      · simp [R,s,hx] at hj
-      exact hx.le
-    by_cases hy : Q (i,false)<γ
-    · cases b
-      · exact hy.le
-      simp [R,s,hx,hy] at hj
-    simp [R,s,hx,hy] at hj
-  have hg (j) : Q j * ind (R j) ≤ γ := by
-    by_cases hh : R j
-    · simpa only [ind_one hh,mul_one] using h1 j hh
-    rw [ind_zero hh,mul_zero]; exact hγ.le
-  simp_rw [Function.comp_apply,he]
-  rw [← mapW_pr]
-  exact (Finset.sum_le_sum fun i _ => hg i).trans_eq (by simp only [Finset.sum_const,
-    Finset.card_univ,nsmul_eq_mul,num])
-
-theorem bucket_upper (w : Wgt B) (hw : SubLaw w) (q : Wgt B) (hq : IsLaw q)
-    (f : B→ C) (δ : ℝ) (h0 : 0<δ) (hz : stamina (mapW q f) δ) :
-    ∀ i,bucket q f w i ≤ δ⁻¹*q i := by
-  intro i
-  have he : mapW w f (f i) ≤1 := by
-    exact (pr_le_tot hw.nz).trans hw.total
-  unfold bucket pour
-  by_cases hi : mapW q f (f i)=0
-  · rw [hi,div_zero,mul_zero]; exact mul_nonneg (inv_pos_of_pos h0).le (hq.nz _)
-  rw [mul_comm δ⁻¹]
-  exact mul_le_mul_of_nonneg_left ((div_le_div₀ zero_le_one he h0 (hz _ hi)).trans_eq
-    (one_div _)) (hq.nz _)
-
-theorem pr_ref_delta (w : Wgt A) (hw : ∀ i,0 ≤ w i) (P Q : A→ Prop) :
-    pr w P ≤ pr w Q + pr w (fun i => ¬(P i↔Q i)) :=
-  (pr_mono hw (q:=fun i => Q i ∨ ¬(P i↔Q i)) fun i _ => by tauto).trans (pr_or_le hw)
-
-variable {μ : Wgt A} {p : A →Wgt B}
-
-set_option maxHeartbeats 1000000 in
-theorem divide_progress [Nonempty B] (h : Ultra μ p)
-    (ε δ α k : ℝ) (hε : 0<ε) (hk : 0<k) (hk' : 2*k≤1)
-    (hδ : 0<δ) (hα : δ≤1)
-    (hB : ∀ P : B→ Prop, pr unif P ≤α → pr (mixW μ p) P ≤ε)
-    (f : B→ C) (hz : stamina (mapW unif f) δ)
-    (hC : num (C×Bool)*k ≤min α ε)
-    (w : Wgt B) (hw : catalog μ p w) (hr : 8*ε<varOne w (bucket unif f w)) :
-    ∃ F : B → C×Bool, stamina (mapW unif F) (k*δ) ∧
-      budget μ p f + ε^2 ≤ budget μ p F := by
-  classical
-  let q : Wgt B := unif
-  have hq : IsLaw q := unif_law
-  let v := bucket q f w
-  have ht := h.cat_sub w hw
-  let P (i : B) := v i < w i
-  have hv (i) : 0≤v i := pour_nz _ hq.nz (map_nz ht.nz f) i
-  have hh : varOne w v=2*(pr w P-pr v P) := by
-    have hx : lsupp w q := fun i _ => by unfold q; rw [unif_apply]; positivity
-    exact var_event w v (by rw [←map_mass w f,←map_mass v f,bucket_scale q w hq.nz hx])
-  obtain ⟨F,hF,hφ,hL⟩ := divide_fit q hq f P δ (k*δ) (by positivity)
-    ((le_of_eq (by rw [← mul_assoc])).trans ((mul_le_mul_of_nonneg_right hk' hδ.le).trans_eq
-      (one_mul _))) hz
-  refine ⟨F,hφ,?_⟩
-  let Q := fun i : B => ((F i).2=true)
-  let S := fun i => ¬(P i ↔ Q i)
-  have h1 : pr w S ≤ ε := by
-    obtain ⟨hu,he⟩ := h.cat_dom w hw
-    have hs : pr q S ≤α := by
-      have hμ := (le_min_iff.mp hC).1
-      have : 0≤num (C×Bool) := Nat.cast_nonneg _
-      exact hL.trans (by nlinarith only [this,hk,hα,hμ,
-        mul_le_mul_of_nonneg_left hα (mul_nonneg this hk.le)])
-    exact (pr_mono_left he S).trans (hB S hs)
-  have h2 : pr v S ≤ ε := by
-    have hh := (pr_cap (bucket_upper w ht q hq f δ hδ hz) S).trans
-      (mul_le_mul_of_nonneg_left hL (inv_pos_of_pos hδ).le)
-    exact hh.trans ((le_of_eq (by field_simp)).trans (le_min_iff.mp hC).2)
-  have h3 : 2*ε < pr w Q-pr v Q := by
-    have he := pr_ref_delta w ht.nz P Q
-    have hr' := pr_ref_delta v hv Q P
-    have heq : (fun i=>¬(Q i↔P i))=S := funext fun i => propext (by unfold S; tauto)
-    rw [heq] at hr'
-    change 8*ε < varOne w v at hr
-    rw [hh] at hr; change pr w P≤pr w Q+pr w S at he
-    linarith only [hr,h1,h2,he,hr']
-  have h4 := var_pr (mapW w F) (mapW v F) (fun i:C×Bool => i.2=true)
-  rw [mapW_pr,mapW_pr] at h4
-  have he := budget_progress h w hw F Prod.fst
-  change varOne _ (mapW (bucket q (Prod.fst ∘ F) w) F) ^ 2 ≤ _ at he
-  rw [← hF] at he
-  nlinarith only [he,hε,(le_trans h3.le h4)]
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.RefinementEnergy
+
+namespace OAI
+
+/-! # Rounded Refinements -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Finset Filter Matrix Real
+open scoped BigOperators
+variable {A B C D : Type} [Fintype A] [Fintype B] [Fintype C] [Fintype D]
+
+set_option maxHeartbeats 900000 in
+theorem divide_fit (q : Wgt B) (hq : IsLaw q) (f : B→C) (P : B→Prop)
+    (δ γ : ℝ) (hγ : 0<γ) (hz : 2*γ ≤ δ) (h : stamina (mapW q f) δ) :
+    ∃ F : B→C×Bool, f=Prod.fst∘F ∧ stamina (mapW q F) γ ∧
+    pr q (fun i => ¬(P i ↔ (F i).2))≤num (C×Bool)*γ := by
+  classical
+  let g (i : B) : C × Bool := (f i,decide (P i))
+  let Q := mapW q g
+  have hQ := mapW_law hq g
+  have hf : f=Prod.fst∘g := rfl
+  have hi (i) : mapW q f i=Q (i,true)+Q (i,false) := by
+    have hs : mapW q f=mapW Q Prod.fst := hf ▸ Eq.symm (map_nested g Prod.fst)
+    rw [hs]
+    simp only [mapW,pr,avg,Fintype.sum_prod_type,Fintype.sum_bool]; simp [ind,Finset.sum_add_distrib]
+  let s (j:C×Bool) : Bool := if Q (j.1,true) < γ then false else
+    if Q (j.1,false) < γ then true else j.2
+  let F (j : C × Bool) : C × Bool := (j.1,s j)
+  refine ⟨F ∘ g,rfl,?_,?_⟩
+  · rintro ⟨i,b⟩ h'
+    have hb :
+        mapW Q F (i,b)=Q (i,true)*ind (s (i,true)=b)+
+          Q (i,false)*ind (s (i,false)=b) := by
+      unfold mapW pr avg
+      rw [Fintype.sum_prod_type, sum_eq_single i]
+      · rw [Fintype.sum_bool]; simp [ind,F]
+      · intro j _ hj; rw [Fintype.sum_bool]; simp [ind,F,hj]
+      simp
+    rw [←map_nested,hb] at h' ⊢
+    by_cases hx : Q (i,true)<γ
+    · cases b
+      · simp only [s,hx,ite_true,ind_true,mul_one] at *
+        rw [←hi] at *
+        exact le_trans (by linarith only [hz,hγ]) (h i h')
+      simp [s,hx,ind] at h'
+    by_cases hy : Q (i,false)<γ
+    · cases b
+      · simp [s,hx,hy,ind] at h'
+      simp only [s,hx,hy,ite_true,ite_false,ind_true,mul_one] at *
+      rw [←hi] at *
+      exact le_trans (by linarith only [hz,hγ]) (h i h')
+    cases b
+    · simpa [s,hx,hy,ind] using (le_of_not_gt hy)
+    simpa [s,hx,hy,ind] using (le_of_not_gt hx)
+  let R (i : C×Bool) := i.2≠s i
+  have he j : (¬ (P j ↔ (F (g j)).2)) ↔ R (g j) := by
+    change (¬ (P j ↔ s (g j)=true)) ↔ decide (P j)≠s (g j)
+    cases s (g j) <;> simp
+  have h1 (j : C×Bool) : R j→ Q j≤γ := by
+    intro hj
+    rcases j with ⟨i,b⟩
+    by_cases hx : Q (i,true)<γ
+    · cases b
+      · simp [R,s,hx] at hj
+      exact hx.le
+    by_cases hy : Q (i,false)<γ
+    · cases b
+      · exact hy.le
+      simp [R,s,hx,hy] at hj
+    simp [R,s,hx,hy] at hj
+  have hg (j) : Q j * ind (R j) ≤ γ := by
+    by_cases hh : R j
+    · simpa only [ind_one hh,mul_one] using h1 j hh
+    rw [ind_zero hh,mul_zero]; exact hγ.le
+  simp_rw [Function.comp_apply,he]
+  rw [← mapW_pr]
+  exact (Finset.sum_le_sum fun i _ => hg i).trans_eq (by simp only [Finset.sum_const,
+    Finset.card_univ,nsmul_eq_mul,num])
+
+theorem bucket_upper (w : Wgt B) (hw : SubLaw w) (q : Wgt B) (hq : IsLaw q)
+    (f : B→ C) (δ : ℝ) (h0 : 0<δ) (hz : stamina (mapW q f) δ) :
+    ∀ i,bucket q f w i ≤ δ⁻¹*q i := by
+  intro i
+  have he : mapW w f (f i) ≤1 := by
+    exact (pr_le_tot hw.nz).trans hw.total
+  unfold bucket pour
+  by_cases hi : mapW q f (f i)=0
+  · rw [hi,div_zero,mul_zero]; exact mul_nonneg (inv_pos_of_pos h0).le (hq.nz _)
+  rw [mul_comm δ⁻¹]
+  exact mul_le_mul_of_nonneg_left ((div_le_div₀ zero_le_one he h0 (hz _ hi)).trans_eq
+    (one_div _)) (hq.nz _)
+
+theorem pr_ref_delta (w : Wgt A) (hw : ∀ i,0 ≤ w i) (P Q : A→ Prop) :
+    pr w P ≤ pr w Q + pr w (fun i => ¬(P i↔Q i)) :=
+  (pr_mono hw (q:=fun i => Q i ∨ ¬(P i↔Q i)) fun i _ => by tauto).trans (pr_or_le hw)
+
+variable {μ : Wgt A} {p : A →Wgt B}
+
+set_option maxHeartbeats 1000000 in
+theorem divide_progress [Nonempty B] (h : Ultra μ p)
+    (ε δ α k : ℝ) (hε : 0<ε) (hk : 0<k) (hk' : 2*k≤1)
+    (hδ : 0<δ) (hα : δ≤1)
+    (hB : ∀ P : B→ Prop, pr unif P ≤α → pr (mixW μ p) P ≤ε)
+    (f : B→ C) (hz : stamina (mapW unif f) δ)
+    (hC : num (C×Bool)*k ≤min α ε)
+    (w : Wgt B) (hw : catalog μ p w) (hr : 8*ε<varOne w (bucket unif f w)) :
+    ∃ F : B → C×Bool, stamina (mapW unif F) (k*δ) ∧
+      budget μ p f + ε^2 ≤ budget μ p F := by
+  classical
+  let q : Wgt B := unif
+  have hq : IsLaw q := unif_law
+  let v := bucket q f w
+  have ht := h.cat_sub w hw
+  let P (i : B) := v i < w i
+  have hv (i) : 0≤v i := pour_nz _ hq.nz (map_nz ht.nz f) i
+  have hh : varOne w v=2*(pr w P-pr v P) := by
+    have hx : lsupp w q := fun i _ => by unfold q; rw [unif_apply]; positivity
+    exact var_event w v (by rw [←map_mass w f,←map_mass v f,bucket_scale q w hq.nz hx])
+  obtain ⟨F,hF,hφ,hL⟩ := divide_fit q hq f P δ (k*δ) (by positivity)
+    ((le_of_eq (by rw [← mul_assoc])).trans ((mul_le_mul_of_nonneg_right hk' hδ.le).trans_eq
+      (one_mul _))) hz
+  refine ⟨F,hφ,?_⟩
+  let Q := fun i : B => ((F i).2=true)
+  let S := fun i => ¬(P i ↔ Q i)
+  have h1 : pr w S ≤ ε := by
+    obtain ⟨hu,he⟩ := h.cat_dom w hw
+    have hs : pr q S ≤α := by
+      have hμ := (le_min_iff.mp hC).1
+      have : 0≤num (C×Bool) := Nat.cast_nonneg _
+      exact hL.trans (by nlinarith only [this,hk,hα,hμ,
+        mul_le_mul_of_nonneg_left hα (mul_nonneg this hk.le)])
+    exact (pr_mono_left he S).trans (hB S hs)
+  have h2 : pr v S ≤ ε := by
+    have hh := (pr_cap (bucket_upper w ht q hq f δ hδ hz) S).trans
+      (mul_le_mul_of_nonneg_left hL (inv_pos_of_pos hδ).le)
+    exact hh.trans ((le_of_eq (by field_simp)).trans (le_min_iff.mp hC).2)
+  have h3 : 2*ε < pr w Q-pr v Q := by
+    have he := pr_ref_delta w ht.nz P Q
+    have hr' := pr_ref_delta v hv Q P
+    have heq : (fun i=>¬(Q i↔P i))=S := funext fun i => propext (by unfold S; tauto)
+    rw [heq] at hr'
+    change 8*ε < varOne w v at hr
+    rw [hh] at hr; change pr w P≤pr w Q+pr w S at he
+    linarith only [hr,h1,h2,he,hr']
+  have h4 := var_pr (mapW w F) (mapW v F) (fun i:C×Bool => i.2=true)
+  rw [mapW_pr,mapW_pr] at h4
+  have he := budget_progress h w hw F Prod.fst
+  change varOne _ (mapW (bucket q (Prod.fst ∘ F) w) F) ^ 2 ≤ _ at he
+  rw [← hF] at he
+  nlinarith only [he,hε,(le_trans h3.le h4)]
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/SampledGraphs.lean

@@ -1,102 +1,102 @@
-import OAI.Combinatorics.HadwigerMatching.BasicMatching
-import Mathlib.Data.Fintype.EquivFin
-import Mathlib.Combinatorics.SimpleGraph.Clique
-import Lean.Elab.Tactic.Omega
-
-namespace OAI
-
-/-! # Sampled Graphs -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open HadwigerMatching Finset
-variable {A V : Type*}
-
-structure Holes (A : Type*) where
-  rel : A → A → Prop
-  sym {x y : A} : rel x y → rel y x
-  irr (x : A) : ¬ rel x x
-  ntri {x y z : A} : rel x y → rel y z → ¬ rel x z
-
-namespace Holes
-
-variable (H : Holes A)
-def unit (p : A × A) := ¬H.rel p.1 p.2
-def conflict (p q : A × A) := H.rel p.1 q.1 ∧ H.rel p.1 q.2 ∧ H.rel p.2 q.1 ∧ H.rel p.2 q.2
-
-theorem no_self_conflict (p : A × A) : ¬ H.conflict p p := fun h => H.irr p.1 h.1
-
-def graph (x : V → A) : SimpleGraph V where
-  Adj i j := i ≠ j ∧ ¬H.rel (x i) (x j)
-  symm := ⟨fun _ _ ⟨hne,h⟩ => ⟨hne.symm,fun h' => h (H.sym h')⟩⟩
-  loopless := ⟨fun _ h => h.1 rfl⟩
-
-theorem indepNum_graph_le [Fintype V] (x : V → A) : (graph H x).indepNum ≤ 2 := by
-  classical
-  obtain ⟨S, hS, he⟩ := (graph H x).exists_isNIndepSet_indepNum
-  rw [← he]
-  by_contra h
-  have hr : Fintype.card (Fin 3) ≤ Fintype.card S := by simp; omega
-  obtain ⟨e⟩ := Function.Embedding.nonempty_of_card_le hr
-  let f : Fin 3 → V := fun i => e i
-  have hf {i j} (h : i ≠ j) : H.rel (x (f i)) (x (f j)) := by
-    by_contra hp
-    apply hS (show f i ∈ (S : Set V) from (e i).property)
-      (show f j ∈ (S : Set V) from (e j).property)
-      (show f i ≠ f j from fun g => h (e.injective (Subtype.ext g)))
-    exact ⟨fun g => h (e.injective (Subtype.ext g)), hp⟩
-  exact H.ntri (hf (i:=0) (j:=1) (by decide)) (hf (j:=2) (by decide))
-    (hf (by decide))
-
-/-- Enumerate endpoints of an actual maximum connected matching on positions to
-obtain pairwise disjoint ordered pairs; their raw unit types do not conflict. -/
-theorem matching_pairs [Fintype V] (x : V → A) :
-    let t := connectedMatchingNumber (graph H x)
-    ∃ e : (Fin t ⊕ Fin t) → V, Function.Injective e ∧
-      let f : Fin t → A × A := fun i => (x (e (.inl i)), x (e (.inr i)))
-      (∀ i, H.unit (f i)) ∧ (∀ i j, ¬H.conflict (f i) (f j)) := by
-  classical
-  let G := graph H x
-  let t := connectedMatchingNumber G
-  obtain ⟨M,hM,hc⟩ := exists_matching_card_eq_number G
-  have ht : Fintype.card M = t := by rw [Fintype.card_coe,hc]
-  let m := (Fintype.equivFinOfCardEq ht).symm
-  let m' (i : Fin t) : Finset V := (m i).val
-  have hm i : m' i ∈ M := (m i).property
-  have hex (i : Fin t) : ∃ v w : V, v ≠ w ∧ m' i = {v,w} :=
-    card_eq_two.mp (hM.1 _ (hm i)).1
-  choose v w hv he using hex
-  let e := Sum.elim v w
-  have hmem (i : Fin t ⊕ Fin t) : e i ∈ m' (Sum.elim id id i) := by
-    cases i <;> simp [e,he]
-  have hminj : Function.Injective m' := fun i j g => m.injective (Subtype.ext g)
-  have hei : Function.Injective e := by
-    intro i j h
-    have hi : Sum.elim id id i = Sum.elim id id j := by
-      by_contra hn
-      have hh := hM.2.1 _ (hm _) _ (hm _) (hminj.ne hn)
-      exact Finset.disjoint_left.mp hh (hmem i) (by rw [h]; exact hmem j)
-    cases i <;> cases j <;> simp_all [e]
-    exact hv _ h.symm
-  refine ⟨e, hei, fun i => ?_, fun i j => ?_⟩
-  · have h1 : v i ∈ m' i := by simp [he]
-    have h2 : w i ∈ m' i := by simp [he]
-    exact ((hM.1 _ (hm i)).2 h1 h2 (hv i)).2
-  · by_cases h : i = j
-    · subst j; exact no_self_conflict _ _
-    · obtain ⟨a,ha,b,hb,hadj⟩ := hM.2.2 _ (hm i) _ (hm j) (hminj.ne h)
-      have ha' : a = v i ∨ a = w i := by simpa [he] using ha
-      have hb' : b = v j ∨ b = w j := by simpa [he] using hb
-      intro hz
-      apply hadj.2
-      rcases ha' with h1|h1 <;> rcases hb' with h2|h2 <;> rw [h1,h2]
-      · exact hz.1
-      · exact hz.2.1
-      · exact hz.2.2.1
-      · exact hz.2.2.2
-end Holes
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerMatching.BasicMatching
+import Mathlib.Data.Fintype.EquivFin
+import Mathlib.Combinatorics.SimpleGraph.Clique
+import Lean.Elab.Tactic.Omega
+
+namespace OAI
+
+/-! # Sampled Graphs -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open HadwigerMatching Finset
+variable {A V : Type*}
+
+structure Holes (A : Type*) where
+  rel : A → A → Prop
+  sym {x y : A} : rel x y → rel y x
+  irr (x : A) : ¬ rel x x
+  ntri {x y z : A} : rel x y → rel y z → ¬ rel x z
+
+namespace Holes
+
+variable (H : Holes A)
+def unit (p : A × A) := ¬H.rel p.1 p.2
+def conflict (p q : A × A) := H.rel p.1 q.1 ∧ H.rel p.1 q.2 ∧ H.rel p.2 q.1 ∧ H.rel p.2 q.2
+
+theorem no_self_conflict (p : A × A) : ¬ H.conflict p p := fun h => H.irr p.1 h.1
+
+def graph (x : V → A) : SimpleGraph V where
+  Adj i j := i ≠ j ∧ ¬H.rel (x i) (x j)
+  symm := ⟨fun _ _ ⟨hne,h⟩ => ⟨hne.symm,fun h' => h (H.sym h')⟩⟩
+  loopless := ⟨fun _ h => h.1 rfl⟩
+
+theorem indepNum_graph_le [Fintype V] (x : V → A) : (graph H x).indepNum ≤ 2 := by
+  classical
+  obtain ⟨S, hS, he⟩ := (graph H x).exists_isNIndepSet_indepNum
+  rw [← he]
+  by_contra h
+  have hr : Fintype.card (Fin 3) ≤ Fintype.card S := by simp; omega
+  obtain ⟨e⟩ := Function.Embedding.nonempty_of_card_le hr
+  let f : Fin 3 → V := fun i => e i
+  have hf {i j} (h : i ≠ j) : H.rel (x (f i)) (x (f j)) := by
+    by_contra hp
+    apply hS (show f i ∈ (S : Set V) from (e i).property)
+      (show f j ∈ (S : Set V) from (e j).property)
+      (show f i ≠ f j from fun g => h (e.injective (Subtype.ext g)))
+    exact ⟨fun g => h (e.injective (Subtype.ext g)), hp⟩
+  exact H.ntri (hf (i:=0) (j:=1) (by decide)) (hf (j:=2) (by decide))
+    (hf (by decide))
+
+/-- Enumerate endpoints of an actual maximum connected matching on positions to
+obtain pairwise disjoint ordered pairs; their raw unit types do not conflict. -/
+theorem matching_pairs [Fintype V] (x : V → A) :
+    let t := connectedMatchingNumber (graph H x)
+    ∃ e : (Fin t ⊕ Fin t) → V, Function.Injective e ∧
+      let f : Fin t → A × A := fun i => (x (e (.inl i)), x (e (.inr i)))
+      (∀ i, H.unit (f i)) ∧ (∀ i j, ¬H.conflict (f i) (f j)) := by
+  classical
+  let G := graph H x
+  let t := connectedMatchingNumber G
+  obtain ⟨M,hM,hc⟩ := exists_matching_card_eq_number G
+  have ht : Fintype.card M = t := by rw [Fintype.card_coe,hc]
+  let m := (Fintype.equivFinOfCardEq ht).symm
+  let m' (i : Fin t) : Finset V := (m i).val
+  have hm i : m' i ∈ M := (m i).property
+  have hex (i : Fin t) : ∃ v w : V, v ≠ w ∧ m' i = {v,w} :=
+    card_eq_two.mp (hM.1 _ (hm i)).1
+  choose v w hv he using hex
+  let e := Sum.elim v w
+  have hmem (i : Fin t ⊕ Fin t) : e i ∈ m' (Sum.elim id id i) := by
+    cases i <;> simp [e,he]
+  have hminj : Function.Injective m' := fun i j g => m.injective (Subtype.ext g)
+  have hei : Function.Injective e := by
+    intro i j h
+    have hi : Sum.elim id id i = Sum.elim id id j := by
+      by_contra hn
+      have hh := hM.2.1 _ (hm _) _ (hm _) (hminj.ne hn)
+      exact Finset.disjoint_left.mp hh (hmem i) (by rw [h]; exact hmem j)
+    cases i <;> cases j <;> simp_all [e]
+    exact hv _ h.symm
+  refine ⟨e, hei, fun i => ?_, fun i j => ?_⟩
+  · have h1 : v i ∈ m' i := by simp [he]
+    have h2 : w i ∈ m' i := by simp [he]
+    exact ((hM.1 _ (hm i)).2 h1 h2 (hv i)).2
+  · by_cases h : i = j
+    · subst j; exact no_self_conflict _ _
+    · obtain ⟨a,ha,b,hb,hadj⟩ := hM.2.2 _ (hm i) _ (hm j) (hminj.ne h)
+      have ha' : a = v i ∨ a = w i := by simpa [he] using ha
+      have hb' : b = v j ∨ b = w j := by simpa [he] using hb
+      intro hz
+      apply hadj.2
+      rcases ha' with h1|h1 <;> rcases hb' with h2|h2 <;> rw [h1,h2]
+      · exact hz.1
+      · exact hz.2.1
+      · exact hz.2.2.1
+      · exact hz.2.2.2
+end Holes
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/ScalarStatusAlgebra.lean

@@ -1,162 +1,162 @@
-import OAI.Combinatorics.HadwigerCounterexample.BasisConditioning
-
-namespace OAI
-
-/-! # Scalar Status Algebra -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Matrix LinearMap Submodule Finset Function Module
-open scoped BigOperators
-
-namespace StatusAnalysis
-abbrev Nodes := Bool
-abbrev Grid := Nodes × Nodes
-abbrev Cell (d : ℕ) := Vec (Fin d)
-
-abbrev Par (d : ℕ) := F × Cell d
-abbrev Whole (d : ℕ) := Par d × F
-
-abbrev Signal (d e : ℕ) := F × Whole d × Whole e
-abbrev View (d e : ℕ) := F × Par d × Par e
-abbrev Question (d e : ℕ) := F × F × Cell d × Cell e
-variable {d e : ℕ}
-
-def view (d e : ℕ) : Signal d e→ₗ[F] View d e where
-  toFun x := (x.1,x.2.1.1,x.2.2.1)
-  map_add' _ _ := rfl
-  map_smul' _ _ := rfl
-def testV (d e : ℕ) : View d e →ₗ[F] Question d e where
-  toFun x := (x.1,x.2.1.1 + x.2.2.1,x.2.1.2,x.2.2.2)
-  map_add' _ _ := Prod.ext rfl (Prod.ext (add_add_add_comm ..) rfl)
-  map_smul' _ _ := Prod.ext rfl (Prod.ext (mul_add _ _ _).symm rfl)
-def want (d e : ℕ) := testV d e ∘ₗ view d e
-
-def couple (d : ℕ) : Whole d→ₗ[F] F where
-  toFun x := x.1.1+x.2
-  map_add' _ _ := add_add_add_comm ..
-  map_smul' a _ := (mul_add a _ _).symm
-
-def coverBase (V : Space (Signal d e)) := Surjective (view d e ∘ₗ V.subtype)
-theorem testV_surj (d e : ℕ) : Surjective (testV d e) := by
-  rintro ⟨a,b,x,y⟩
-  exact ⟨(a,(b,x),(0,y)),Prod.ext rfl (Prod.ext (add_zero _) rfl)⟩
-theorem coversFull {V : Space (Signal d e)} (h : coverBase V) : Surjective (want d e ∘ₗ V.subtype) :=
-  (testV_surj _ _).comp h
-
-abbrev Rates := Nodes→ℕ
-abbrev Suite (A B : Rates) (i : Grid) := Signal (A i.1) (B i.2)
-abbrev LedgerS (A B : Rates) (i : Grid) := Question (A i.1) (B i.2)
-abbrev Cabinet (A B : Rates) := ∀ i, LedgerS A B i
-abbrev Quota := Vec Nodes
-abbrev Court (A B : Rates) := Cabinet A B × Quota × Quota
-abbrev StatusSp (A B : Rates) := ∀ i,Space (Suite A B i)
-variable {A B : Rates}
-
-def separate (A B : Rates) (i : Grid) :
-    Suite A B i →ₗ[F] Court A B :=
-  (LinearMap.single F (LedgerS A B) i ∘ₗ want _ _).prod
-    ((LinearMap.single F (fun _ : Bool=>F) i.2 ∘ₗ
-      (couple (A i.1) ∘ₗ LinearMap.fst F _ _ ∘ₗ LinearMap.snd F _ _)).prod
-     (LinearMap.single F (fun _ : Bool=>F) i.1 ∘ₗ
-      (couple (B i.2) ∘ₗ LinearMap.snd F _ _ ∘ₗ LinearMap.snd F _ _)))
-
-def speak (A B : Rates) :
-    (∀ i,Suite A B i) →ₗ[F] Court A B := ∑ i:Grid,separate A B i ∘ₗ LinearMap.proj i
-
-theorem speak_solo (A B : Rates) (i : Grid) (x : Suite A B i) :
-    speak A B (Pi.single i x)=separate A B i x := by
-  classical
-  unfold speak; rw [LinearMap.sum_apply,sum_eq_single i]
-  · rw [LinearMap.comp_apply]; change separate _ _ _ ((Pi.single i x : ∀ i, Suite A B i) i)=_
-    rw [Pi.single_eq_same]
-  · intro j _ hj; rw [LinearMap.comp_apply]
-    change separate _ _ _ ((Pi.single i x : ∀ i, Suite A B i) j)=_
-    rw [Pi.single_eq_of_ne hj,map_zero]
-  simp
-
-def scorecard (V : StatusSp A B) (T : Cabinet A B) :=
-  ∃ v : ∀ i,Suite A B i,(∀ i,v i∈V i) ∧ speak A B v=(T,0)
-
-structure Critic (A B : Rates) where
-  alf : ∀ i : Grid, LedgerS A B i →ₗ[F] F
-  altL : Quota
-  altR : Quota
-def Counter (g : Critic A B) (V : StatusSp A B) :=
-  ∀ i:Grid,∀ v∈V i, g.alf i (want _ _ v) =
-    g.altL i.2 * couple _ v.2.1 + g.altR i.1 * couple _ v.2.2
-
-private theorem vanishes {M : Type} [AddCommGroup M] [Module F M] (V : Space M) {z}
-    (h : z∉ V) :
-    ∃ f:M→ₗ[F] F,f z ≠0 ∧ ∀ i∈V,f i=0 := by
-  have he : V.mkQ z ≠0 := fun hg=>h ((Submodule.Quotient.mk_eq_zero V).mp hg)
-  obtain ⟨f,hf⟩ := Module.Projective.exists_dual_ne_zero F he
-  exact ⟨f ∘ₗ V.mkQ,hf,fun i hi =>by rw [LinearMap.comp_apply,show V.mkQ i=0 from
-    (Submodule.Quotient.mk_eq_zero V).mpr hi,map_zero]⟩
-
-set_option maxHeartbeats 800000 in
-theorem counter_score (V : StatusSp A B) (T : Cabinet A B)
-    (h : ¬scorecard V T) :
-    ∃ g : Critic A B,Counter g V ∧ ∑ i,g.alf i (T i)≠0 := by
-  classical
-  let S := (Submodule.pi Set.univ V).map (speak A B)
-  have ht : (T,(0 : Quota × Quota))∉ S := by
-    rintro ⟨z,hz,he⟩
-    exact h ⟨z,fun i => hz i (Set.mem_univ _),he⟩
-  obtain ⟨f,hf,hx⟩ := vanishes S ht
-  let g : Critic A B := {
-    alf := fun i => f ∘ₗ LinearMap.inl F (Cabinet A B) _ ∘ₗ LinearMap.single F _ i
-    altL := fun i=> f (0,Pi.single i 1,0)
-    altR := fun i=> f (0,0,Pi.single i 1) }
-  refine ⟨g,fun i v hv => ?_,?_⟩
-  · have hi :
-        f (separate A B i v)=0 := by
-      apply hx
-      refine ⟨Pi.single i v,?_,speak_solo A B i v⟩
-      intro j _
-      by_cases ht : j=i
-      · subst j; rwa [Pi.single_eq_same]
-      rw [Pi.single_eq_of_ne ht]; exact zero_mem _
-    let a:= couple _ v.2.1
-    let b:= couple _ v.2.2
-    let Q:= want _ _ v
-    have hh (a:F) (i:Bool) :
-       (a • Pi.single i 1 : Quota)=Pi.single i a := by
-      ext j; by_cases he:j=i <;> simp [he]
-    have hz :
-        separate A B i v =
-        ( (Pi.single i Q : Cabinet A B),0) + (a • (0,Pi.single i.2 1,(0:Quota))+
-          b • (0,(0:Quota),Pi.single i.1 1)) := by
-      change ((Pi.single i Q:Cabinet A B),(Pi.single i.2 a:Quota),(Pi.single i.1 b:Quota))=_
-      apply Prod.ext; simp
-      apply Prod.ext <;> simp [hh]
-    rw [hz,map_add,map_add,map_smul,map_smul] at hi
-    change g.alf i Q+(a*g.altL i.2+b*g.altR i.1)=0 at hi
-    change _=g.altL _ * a+g.altR _ * b
-    rw [mul_comm _ a,mul_comm _ b]
-    exact add_right_cancel (hi.trans (char_two _).symm)
-  · have hh (i) : g.alf i (T i)=f ((Pi.single i (T i) : Cabinet A B),0) := rfl
-    have ht : ∑ i:Grid, ((Pi.single i (T i) : Cabinet A B),(0 : Quota × Quota))=
-        (T,0) := by
-      apply Prod.ext
-      · rw [Prod.fst_sum]; exact Finset.univ_sum_single _
-      · simp only [Prod.snd_sum,Finset.sum_const_zero]
-    simp_rw [hh, ← map_sum,ht]
-    exact hf
-
-theorem critic_nz (V : StatusSp A B) (T : Cabinet A B) (hV : ∀ i,coverBase (V i)) (g : Critic A B)
-    (h : Counter g V) (hh : ∑ i,g.alf i (T i)≠0) : g.altL≠0 ∨ g.altR≠0 := by
-  classical
-  by_contra! hz
-  apply hh; apply Finset.sum_eq_zero
-  intro i _
-  obtain ⟨⟨v,hv⟩,ht⟩ := coversFull (hV i) (T i)
-  simpa only [show want (A i.1) (B i.2) v=T i from ht,hz.1,hz.2,Pi.zero_apply,zero_mul,add_zero]
-    using h i v hv
-
-end StatusAnalysis
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.BasisConditioning
+
+namespace OAI
+
+/-! # Scalar Status Algebra -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Matrix LinearMap Submodule Finset Function Module
+open scoped BigOperators
+
+namespace StatusAnalysis
+abbrev Nodes := Bool
+abbrev Grid := Nodes × Nodes
+abbrev Cell (d : ℕ) := Vec (Fin d)
+
+abbrev Par (d : ℕ) := F × Cell d
+abbrev Whole (d : ℕ) := Par d × F
+
+abbrev Signal (d e : ℕ) := F × Whole d × Whole e
+abbrev View (d e : ℕ) := F × Par d × Par e
+abbrev Question (d e : ℕ) := F × F × Cell d × Cell e
+variable {d e : ℕ}
+
+def view (d e : ℕ) : Signal d e→ₗ[F] View d e where
+  toFun x := (x.1,x.2.1.1,x.2.2.1)
+  map_add' _ _ := rfl
+  map_smul' _ _ := rfl
+def testV (d e : ℕ) : View d e →ₗ[F] Question d e where
+  toFun x := (x.1,x.2.1.1 + x.2.2.1,x.2.1.2,x.2.2.2)
+  map_add' _ _ := Prod.ext rfl (Prod.ext (add_add_add_comm ..) rfl)
+  map_smul' _ _ := Prod.ext rfl (Prod.ext (mul_add _ _ _).symm rfl)
+def want (d e : ℕ) := testV d e ∘ₗ view d e
+
+def couple (d : ℕ) : Whole d→ₗ[F] F where
+  toFun x := x.1.1+x.2
+  map_add' _ _ := add_add_add_comm ..
+  map_smul' a _ := (mul_add a _ _).symm
+
+def coverBase (V : Space (Signal d e)) := Surjective (view d e ∘ₗ V.subtype)
+theorem testV_surj (d e : ℕ) : Surjective (testV d e) := by
+  rintro ⟨a,b,x,y⟩
+  exact ⟨(a,(b,x),(0,y)),Prod.ext rfl (Prod.ext (add_zero _) rfl)⟩
+theorem coversFull {V : Space (Signal d e)} (h : coverBase V) : Surjective (want d e ∘ₗ V.subtype) :=
+  (testV_surj _ _).comp h
+
+abbrev Rates := Nodes→ℕ
+abbrev Suite (A B : Rates) (i : Grid) := Signal (A i.1) (B i.2)
+abbrev LedgerS (A B : Rates) (i : Grid) := Question (A i.1) (B i.2)
+abbrev Cabinet (A B : Rates) := ∀ i, LedgerS A B i
+abbrev Quota := Vec Nodes
+abbrev Court (A B : Rates) := Cabinet A B × Quota × Quota
+abbrev StatusSp (A B : Rates) := ∀ i,Space (Suite A B i)
+variable {A B : Rates}
+
+def separate (A B : Rates) (i : Grid) :
+    Suite A B i →ₗ[F] Court A B :=
+  (LinearMap.single F (LedgerS A B) i ∘ₗ want _ _).prod
+    ((LinearMap.single F (fun _ : Bool=>F) i.2 ∘ₗ
+      (couple (A i.1) ∘ₗ LinearMap.fst F _ _ ∘ₗ LinearMap.snd F _ _)).prod
+     (LinearMap.single F (fun _ : Bool=>F) i.1 ∘ₗ
+      (couple (B i.2) ∘ₗ LinearMap.snd F _ _ ∘ₗ LinearMap.snd F _ _)))
+
+def speak (A B : Rates) :
+    (∀ i,Suite A B i) →ₗ[F] Court A B := ∑ i:Grid,separate A B i ∘ₗ LinearMap.proj i
+
+theorem speak_solo (A B : Rates) (i : Grid) (x : Suite A B i) :
+    speak A B (Pi.single i x)=separate A B i x := by
+  classical
+  unfold speak; rw [LinearMap.sum_apply,sum_eq_single i]
+  · rw [LinearMap.comp_apply]; change separate _ _ _ ((Pi.single i x : ∀ i, Suite A B i) i)=_
+    rw [Pi.single_eq_same]
+  · intro j _ hj; rw [LinearMap.comp_apply]
+    change separate _ _ _ ((Pi.single i x : ∀ i, Suite A B i) j)=_
+    rw [Pi.single_eq_of_ne hj,map_zero]
+  simp
+
+def scorecard (V : StatusSp A B) (T : Cabinet A B) :=
+  ∃ v : ∀ i,Suite A B i,(∀ i,v i∈V i) ∧ speak A B v=(T,0)
+
+structure Critic (A B : Rates) where
+  alf : ∀ i : Grid, LedgerS A B i →ₗ[F] F
+  altL : Quota
+  altR : Quota
+def Counter (g : Critic A B) (V : StatusSp A B) :=
+  ∀ i:Grid,∀ v∈V i, g.alf i (want _ _ v) =
+    g.altL i.2 * couple _ v.2.1 + g.altR i.1 * couple _ v.2.2
+
+private theorem vanishes {M : Type} [AddCommGroup M] [Module F M] (V : Space M) {z}
+    (h : z∉ V) :
+    ∃ f:M→ₗ[F] F,f z ≠0 ∧ ∀ i∈V,f i=0 := by
+  have he : V.mkQ z ≠0 := fun hg=>h ((Submodule.Quotient.mk_eq_zero V).mp hg)
+  obtain ⟨f,hf⟩ := Module.Projective.exists_dual_ne_zero F he
+  exact ⟨f ∘ₗ V.mkQ,hf,fun i hi =>by rw [LinearMap.comp_apply,show V.mkQ i=0 from
+    (Submodule.Quotient.mk_eq_zero V).mpr hi,map_zero]⟩
+
+set_option maxHeartbeats 800000 in
+theorem counter_score (V : StatusSp A B) (T : Cabinet A B)
+    (h : ¬scorecard V T) :
+    ∃ g : Critic A B,Counter g V ∧ ∑ i,g.alf i (T i)≠0 := by
+  classical
+  let S := (Submodule.pi Set.univ V).map (speak A B)
+  have ht : (T,(0 : Quota × Quota))∉ S := by
+    rintro ⟨z,hz,he⟩
+    exact h ⟨z,fun i => hz i (Set.mem_univ _),he⟩
+  obtain ⟨f,hf,hx⟩ := vanishes S ht
+  let g : Critic A B := {
+    alf := fun i => f ∘ₗ LinearMap.inl F (Cabinet A B) _ ∘ₗ LinearMap.single F _ i
+    altL := fun i=> f (0,Pi.single i 1,0)
+    altR := fun i=> f (0,0,Pi.single i 1) }
+  refine ⟨g,fun i v hv => ?_,?_⟩
+  · have hi :
+        f (separate A B i v)=0 := by
+      apply hx
+      refine ⟨Pi.single i v,?_,speak_solo A B i v⟩
+      intro j _
+      by_cases ht : j=i
+      · subst j; rwa [Pi.single_eq_same]
+      rw [Pi.single_eq_of_ne ht]; exact zero_mem _
+    let a:= couple _ v.2.1
+    let b:= couple _ v.2.2
+    let Q:= want _ _ v
+    have hh (a:F) (i:Bool) :
+       (a • Pi.single i 1 : Quota)=Pi.single i a := by
+      ext j; by_cases he:j=i <;> simp [he]
+    have hz :
+        separate A B i v =
+        ( (Pi.single i Q : Cabinet A B),0) + (a • (0,Pi.single i.2 1,(0:Quota))+
+          b • (0,(0:Quota),Pi.single i.1 1)) := by
+      change ((Pi.single i Q:Cabinet A B),(Pi.single i.2 a:Quota),(Pi.single i.1 b:Quota))=_
+      apply Prod.ext; simp
+      apply Prod.ext <;> simp [hh]
+    rw [hz,map_add,map_add,map_smul,map_smul] at hi
+    change g.alf i Q+(a*g.altL i.2+b*g.altR i.1)=0 at hi
+    change _=g.altL _ * a+g.altR _ * b
+    rw [mul_comm _ a,mul_comm _ b]
+    exact add_right_cancel (hi.trans (char_two _).symm)
+  · have hh (i) : g.alf i (T i)=f ((Pi.single i (T i) : Cabinet A B),0) := rfl
+    have ht : ∑ i:Grid, ((Pi.single i (T i) : Cabinet A B),(0 : Quota × Quota))=
+        (T,0) := by
+      apply Prod.ext
+      · rw [Prod.fst_sum]; exact Finset.univ_sum_single _
+      · simp only [Prod.snd_sum,Finset.sum_const_zero]
+    simp_rw [hh, ← map_sum,ht]
+    exact hf
+
+theorem critic_nz (V : StatusSp A B) (T : Cabinet A B) (hV : ∀ i,coverBase (V i)) (g : Critic A B)
+    (h : Counter g V) (hh : ∑ i,g.alf i (T i)≠0) : g.altL≠0 ∨ g.altR≠0 := by
+  classical
+  by_contra! hz
+  apply hh; apply Finset.sum_eq_zero
+  intro i _
+  obtain ⟨⟨v,hv⟩,ht⟩ := coversFull (hV i) (T i)
+  simpa only [show want (A i.1) (B i.2) v=T i from ht,hz.1,hz.2,Pi.zero_apply,zero_mul,add_zero]
+    using h i v hv
+
+end StatusAnalysis
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/ScriptGramCorrespondence.lean

@@ -1,104 +1,104 @@
-import OAI.Combinatorics.HadwigerCounterexample.EndpointEvaluations
-
-namespace OAI
-
-/-! # Script Gram Correspondence -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Finset Matrix LinearMap Function
-open scoped BigOperators
-variable {p : Shape} {n N : ℕ} {I : Type} [Fintype I] [DecidableEq I]
-
-namespace Template
-variable (v : Template p I)
-
-def lyrics (s : Script p I) (i : v.Chorus) : Vec (v.Abbey i) :=
-  match i with
-  | .inl z => Sum.elim (fun j => if j.2 then s z.val.1 z.val.2 j.1 else s z.val.2 z.val.1 j.1)
-    (fun _ => 0)
-  | .inr _ => 0
-def performs (s : Script p I) (m : Mixer p n) (x : UnitType p n N) (z : Inputs p n I) :=
-  listen v.choral (v.chime m x) z=v.lyrics s
-
-omit [DecidableEq I] in
-theorem across_duet (v : Template p I) {i j} (h : i ≠ j) :
-    ∃ k : v.Chorus,v.verses k=(i,j)∨v.verses k=(j,i) := by
-  classical
-  let e := Fintype.equivFin I
-  by_cases hg : v.aim i=v.aim j
-  · rcases lt_or_gt_of_ne (e.injective.ne h) with hh|hh
-    · exact ⟨.inl ⟨⟨i,j⟩,hg,hh⟩,Or.inl rfl⟩
-    exact ⟨.inl ⟨⟨j,i⟩,hg.symm,hh⟩,Or.inr rfl⟩
-  cases hi : v.aim i <;> cases hj : v.aim j
-  · simp [hi,hj] at hg
-  · exact ⟨.inr ⟨⟨j,i⟩,hj,hi⟩,Or.inr rfl⟩
-  · exact ⟨.inr ⟨⟨i,j⟩,hi,hj⟩,Or.inl rfl⟩
-  simp [hi,hj] at hg
-
-def voices (v : Template p I) (x : Keys (p:=p) v.t N) (i j) (e : Comp p.g) (a : inc e (v.t i))
-    (b : inc e (v.t j)) (q : Bool) :=
-  dotProduct (x i ⟨e,a⟩ q) (x j ⟨e,b⟩ (!q))
-
-omit [Fintype I] [DecidableEq I] in
-theorem voice_note (v : Template p I) (x : UnitType p n N) (z : Inputs p n I)
-    (e : Comp p.g) (i j) (a : inc e (v.t i)) (b : inc e (v.t j)) (q : Bool) :
-    v.voices ((v.draw z).keys v.t x) i j e a b q=evmat
-      (duel p (onSide x (v.aim i) e) (onSide x (v.aim j) e) q)
-        (v.croon i (z i)) (v.croon j (z j)) := by
-  let P := primary (takeSign (p:=p) (onSide x (v.aim i) e) q)
-  let Q := primary (takeSign (p:=p) (onSide x (v.aim j) e) (!q))
-  let u := v.croon i (z i); let t := v.croon j (z j)
-  change dotProduct (P *ᵥ u) (Q *ᵥ t)=dotProduct u ((Pᵀ *Q)*ᵥ t)
-  rw [← mulVec_mulVec,dotProduct_transpose_mulVec]
-  exact dotProduct_comm _ _
-
-omit [Fintype I] [DecidableEq I] in
-theorem voice_same (v : Template p I) (x : UnitType p n N) (z : Inputs p n I)
-    (m : Mixer p n) (hw : ∀ i,frameLaw m (onSide x i))
-    (e : Comp p.g) (i j) (a : inc e (v.t i)) (b : inc e (v.t j))
-    (h : v.aim i=v.aim j) (q : Bool) :
-    v.voices ((v.draw z).keys v.t x) i j e a b q=evmat
-      (eitherM q (selfM p n m.mixM)) (v.croon i (z i)) (v.croon j (z j)) := by
-  rw [voice_note,h]
-  let y := onSide x (v.aim j) e
-  have he : (primary y.1)ᵀ*primary y.2=selfM p n m.mixM := (hw (v.aim j) e).2.2.1
-  congr 1
-  unfold duel
-  cases q
-  · change (primary y.2)ᵀ*primary y.1=_
-    rw [←he]; simp only [eitherM,Bool.false_eq_true,ite_false, transpose_mul,transpose_transpose]
-  exact he
-
-def verges (v : Template p I) (x : Keys (p:=p) v.t N) (i j) :=
-  ∀ e a b q,v.voices x i j e a b q=0
-omit [Fintype I] [DecidableEq I] in
-theorem verges_rev (v : Template p I) {x : Keys (p:=p) v.t N} {i j}
-    (h : v.verges x i j) : v.verges x j i := by
-  intro e a b q
-  have ht := h e b a (!q)
-  unfold voices at *; rw [dotProduct_comm]; rwa [Bool.not_not] at ht
-
-omit [Fintype I] [DecidableEq I] in
-theorem voices_diag (v : Template p I) (m : Mixer p n) (x : UnitType p n N)
-    (w : Inputs p n I) (hw : ∀ i,frameLaw m (onSide x i)) (hj : 1≤p.j) (i : I) :
-    ownOne p (v.t i) (dialed p (v.t i) (v.f i) (w i))
-      ((v.draw w).keys v.t x i) := by
-  intro e
-  let y := (v.draw w).par i
-  let A := mom p (v.s i) y
-  have h : A∈Wspace p n := Submodule.subset_span ⟨_,_,rfl⟩
-  have he := v.voice_same x w m hw e.val i i e.property e.property rfl true
-  let E := selfM p n m.mixM
-  change v.voices _ i i e.val e.property e.property true=_
-  rw [he]
-  change evmat E (point p _ y) (point p _ y)=_
-  rw [← mpair_outer]
-  exact (selfM_pair p hj m.mixM h).trans (etaScan p (n:=n) (v.t i) (v.s i) _ (w i)).symm
-
-end Template
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.EndpointEvaluations
+
+namespace OAI
+
+/-! # Script Gram Correspondence -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Finset Matrix LinearMap Function
+open scoped BigOperators
+variable {p : Shape} {n N : ℕ} {I : Type} [Fintype I] [DecidableEq I]
+
+namespace Template
+variable (v : Template p I)
+
+def lyrics (s : Script p I) (i : v.Chorus) : Vec (v.Abbey i) :=
+  match i with
+  | .inl z => Sum.elim (fun j => if j.2 then s z.val.1 z.val.2 j.1 else s z.val.2 z.val.1 j.1)
+    (fun _ => 0)
+  | .inr _ => 0
+def performs (s : Script p I) (m : Mixer p n) (x : UnitType p n N) (z : Inputs p n I) :=
+  listen v.choral (v.chime m x) z=v.lyrics s
+
+omit [DecidableEq I] in
+theorem across_duet (v : Template p I) {i j} (h : i ≠ j) :
+    ∃ k : v.Chorus,v.verses k=(i,j)∨v.verses k=(j,i) := by
+  classical
+  let e := Fintype.equivFin I
+  by_cases hg : v.aim i=v.aim j
+  · rcases lt_or_gt_of_ne (e.injective.ne h) with hh|hh
+    · exact ⟨.inl ⟨⟨i,j⟩,hg,hh⟩,Or.inl rfl⟩
+    exact ⟨.inl ⟨⟨j,i⟩,hg.symm,hh⟩,Or.inr rfl⟩
+  cases hi : v.aim i <;> cases hj : v.aim j
+  · simp [hi,hj] at hg
+  · exact ⟨.inr ⟨⟨j,i⟩,hj,hi⟩,Or.inr rfl⟩
+  · exact ⟨.inr ⟨⟨i,j⟩,hi,hj⟩,Or.inl rfl⟩
+  simp [hi,hj] at hg
+
+def voices (v : Template p I) (x : Keys (p:=p) v.t N) (i j) (e : Comp p.g) (a : inc e (v.t i))
+    (b : inc e (v.t j)) (q : Bool) :=
+  dotProduct (x i ⟨e,a⟩ q) (x j ⟨e,b⟩ (!q))
+
+omit [Fintype I] [DecidableEq I] in
+theorem voice_note (v : Template p I) (x : UnitType p n N) (z : Inputs p n I)
+    (e : Comp p.g) (i j) (a : inc e (v.t i)) (b : inc e (v.t j)) (q : Bool) :
+    v.voices ((v.draw z).keys v.t x) i j e a b q=evmat
+      (duel p (onSide x (v.aim i) e) (onSide x (v.aim j) e) q)
+        (v.croon i (z i)) (v.croon j (z j)) := by
+  let P := primary (takeSign (p:=p) (onSide x (v.aim i) e) q)
+  let Q := primary (takeSign (p:=p) (onSide x (v.aim j) e) (!q))
+  let u := v.croon i (z i); let t := v.croon j (z j)
+  change dotProduct (P *ᵥ u) (Q *ᵥ t)=dotProduct u ((Pᵀ *Q)*ᵥ t)
+  rw [← mulVec_mulVec,dotProduct_transpose_mulVec]
+  exact dotProduct_comm _ _
+
+omit [Fintype I] [DecidableEq I] in
+theorem voice_same (v : Template p I) (x : UnitType p n N) (z : Inputs p n I)
+    (m : Mixer p n) (hw : ∀ i,frameLaw m (onSide x i))
+    (e : Comp p.g) (i j) (a : inc e (v.t i)) (b : inc e (v.t j))
+    (h : v.aim i=v.aim j) (q : Bool) :
+    v.voices ((v.draw z).keys v.t x) i j e a b q=evmat
+      (eitherM q (selfM p n m.mixM)) (v.croon i (z i)) (v.croon j (z j)) := by
+  rw [voice_note,h]
+  let y := onSide x (v.aim j) e
+  have he : (primary y.1)ᵀ*primary y.2=selfM p n m.mixM := (hw (v.aim j) e).2.2.1
+  congr 1
+  unfold duel
+  cases q
+  · change (primary y.2)ᵀ*primary y.1=_
+    rw [←he]; simp only [eitherM,Bool.false_eq_true,ite_false, transpose_mul,transpose_transpose]
+  exact he
+
+def verges (v : Template p I) (x : Keys (p:=p) v.t N) (i j) :=
+  ∀ e a b q,v.voices x i j e a b q=0
+omit [Fintype I] [DecidableEq I] in
+theorem verges_rev (v : Template p I) {x : Keys (p:=p) v.t N} {i j}
+    (h : v.verges x i j) : v.verges x j i := by
+  intro e a b q
+  have ht := h e b a (!q)
+  unfold voices at *; rw [dotProduct_comm]; rwa [Bool.not_not] at ht
+
+omit [Fintype I] [DecidableEq I] in
+theorem voices_diag (v : Template p I) (m : Mixer p n) (x : UnitType p n N)
+    (w : Inputs p n I) (hw : ∀ i,frameLaw m (onSide x i)) (hj : 1≤p.j) (i : I) :
+    ownOne p (v.t i) (dialed p (v.t i) (v.f i) (w i))
+      ((v.draw w).keys v.t x i) := by
+  intro e
+  let y := (v.draw w).par i
+  let A := mom p (v.s i) y
+  have h : A∈Wspace p n := Submodule.subset_span ⟨_,_,rfl⟩
+  have he := v.voice_same x w m hw e.val i i e.property e.property rfl true
+  let E := selfM p n m.mixM
+  change v.voices _ i i e.val e.property e.property true=_
+  rw [he]
+  change evmat E (point p _ y) (point p _ y)=_
+  rw [← mpair_outer]
+  exact (selfM_pair p hj m.mixM h).trans (etaScan p (n:=n) (v.t i) (v.s i) _ (w i)).symm
+
+end Template
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/SimultaneousProjection.lean

@@ -1,142 +1,142 @@
-import OAI.Combinatorics.HadwigerCounterexample.AdaptiveProjectionBounds
-
-namespace OAI
-
-/-! # Simultaneous Projection -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Filter Finset Matrix
-open scoped BigOperators Topology
-namespace StatusAnalysis
-open Station PreparationParameters
-
-variable {p : Shape} {M s0 n N K : ℕ} {q:Format} {d e:Rates}
-    {l:Filter ℕ} {b:PreparationParameters} {m:cycleM p} {w:tale p M} {s:rhythms p M}
-
-def sparks (v : Stations p M b.pins s) (i:Scrip p b.pins) (m:cycleM p) (w:tale p M)
-    {r} (n:ℕ) (Y: Silhouette p (M*n) r) :=
-  Station.stratum (v n) i.2.2 (m n) (w n) i.2.1 Y
-
-def bullseye (v: Stations p M K s) (m:cycleM p) (w:tale p M) (x:Typus p q d e)
-    (k : Fin (2^deckMax p K)) (ε : ℝ) {r : ℕ} (n : ℕ) (Y : Silhouette p (M*n) r)
-    (τ u:ℝ) :=
-  ∀ (r':ℕ) (Y':Silhouette p (M*n) r'),refines Y' Y →
-  ∀ τ' δ:ℝ,τ'≤τ →
-    pr ((s n).sap (w n)) (fun i=>¬ gauze p τ' δ Y' (m n) K i) ≤u →
-    Station.stratum (v n) x (m n) (w n) k Y'≤ ε
-
-set_option maxHeartbeats 2400000 in
-theorem glowLamp (v:Stations p M b.pins s) (h:veil p M b s0 l m s w) (x:Typus p q d e)
-    (k:Fin (2^deckMax p b.pins)) (hP:x.permission) (ε:ℝ) (he:0<ε) :
-    ∃ (r : ℕ) (τ u:ℝ), 0<τ∧0<u∧∀ᶠ n in l,∃ Y:Silhouette p (M*n) r,
-      bullseye v m w x k ε n Y τ u := by
-  classical
-  have hq:=h.easel; have ht:=hq.enter.first
-  obtain ⟨z,η,hη,hX⟩:=projectCut x hP k h v ε he
-  let a:= η/(12*(z+1:ℝ))
-  have ha:0<a:=by unfold a; positivity
-  obtain ⟨i,u,c,hi,hc,hA⟩:= x.qA.sideRelease x.t x.z M hq hP.2.1 a ha
-  obtain ⟨j,v',C,hj,hC,hB⟩:= x.qB.sideRelease x.t x.z M hq hP.2.2.1 a ha
-  let f:=fun _ : Fin z=>i*j; let r:=bouquet f
-  let τ:= min u v'
-  refine ⟨r,τ,a,lt_min hi hj,ha,?_⟩
-  have hz:= (trend_sizes l h.timeL ht.hM).2
-  filter_upwards [hX,h.upright,h.durableS.shape,h.durableS.mass.positive,h.moment,
-    hA.filter_mono h.timeL,hB.filter_mono h.timeL,
-    ((bp_nat_vanish hc).eventually (eventually_le_nhds ha)).filter_mono h.timeL,
-    ((bp_nat_vanish hC).eventually (eventually_le_nhds ha)).filter_mono h.timeL,
-    hz.eventually (eventually_ge_atTop (2*num (Messenger q×Toast p)+1))]
-    with n hn ha' hB' hW he' hA hB hM hV hG
-  let N:=M*n; let p0:=s n
-  obtain ⟨P,hP'⟩:=hn
-  let e k y:=ind (P y=k)
-  have heq k y : |e k y| ≤1 := by unfold e; rw [abs_of_nonneg (ind_nonneg _)]; exact ind_le_one _
-  choose X hF using fun i:Fin z=> hA (e i) (heq i)
-  choose Z hF' using fun i:Fin z=> hB (e i) (heq i)
-  let Y k:=duoY (X k) (Z k)
-  refine ⟨bundleY f Y,fun r Y' hR τ' δ hτ hpos=>?_⟩
-  apply hP' r Y'
-  have hw:=he'.1.law
-  let hh:=hB'.1
-  have hx' i : IsLaw (x.qA.policies x.t x.z n i) :=
-    Appearance.witLaw (x.qA.allure_apt _ _ hP.2.1 _) ht.hR ha'.age
-  have hy' i : IsLaw (x.qB.policies x.t x.z n i) :=
-    Appearance.witLaw (x.qB.allure_apt _ _ hP.2.2.1 _) ht.hR ha'.age
-  have hN:= show 2*num (Messenger q×Toast p)-(N:ℝ) ≤ -1 from by
-    change _ ≤ (N:ℝ) at hG; linarith only [hG]
-  have hp := nuLaw x.t x.z hN
-  have ht' : ∀ i:Fin z,refines Y' (Y i) := fun i=> refines_next hR (bundle_refines f Y i)
-  refine (projectSum (v n) x (m n) k (w n) Y' P hh.part hw (fun i hi=>(hh.leaf i hi).pos)
-    hW hx' hy' hp a u v' τ' a δ ha.le hP ⟨hτ.trans (min_le_left ..),hτ.trans (min_le_right ..)⟩
-    hpos (fun i=>?_) (fun i=>?_)).trans ?_
-  · exact (hF i _ Y' (refines_next (ht' i) (duo_good ..).1) _ _ ha').trans hM
-  · exact (hF' i _ Y' (refines_next (ht' i) (duo_good ..).2) _ _ ha').trans hV
-  have hi : 12*(z+1:ℝ)*a=η := by unfold a; field_simp
-  nlinarith only [hi,ha,(Nat.cast_nonneg z : 0≤(z:ℝ))]
-
-private theorem minimums {A:Type} [Fintype A] (x : Wgt A) (hx:∀ i,0<x i) :
-    ∃ ε : ℝ,0<ε ∧ ∀ i, ε ≤ x i := by
-  classical
-  cases isEmpty_or_nonempty A
-  next he => exact ⟨1,zero_lt_one,fun i=> (he.false i).elim⟩
-  next he =>
-    let f:= univ.image x
-    have hf : f.Nonempty := Finset.image_nonempty.mpr Finset.univ_nonempty
-    obtain ⟨i,hi,ht⟩:= mem_image.mp (Finset.min'_mem _ hf)
-    exact ⟨f.min' hf,ht ▸ hx i,fun i=>Finset.min'_le _ _ (mem_image_of_mem _ (mem_univ i))⟩
-
-set_option maxHeartbeats 1400000 in
-theorem twinkle (v:Stations p M b.pins s) (h:veil p M b s0 l m s w)
-    (ε:ℝ) (he:0<ε) :
-    ∃ (r : ℕ) (τ u:ℝ),0<τ∧0<u∧∀ᶠ n in l,∃ Y:Silhouette p (M*n) r,
-      ∀ i:Scrip p b.pins, i.2.2.permission → bullseye v m w i.2.2 i.2.1 ε n Y τ u := by
-  classical
-  choose r q A hr hq hh using
-    (fun i:Scrip p b.pins=> show ∃ (r : ℕ) (τ u:ℝ),0<τ∧0<u∧∀ᶠ n in l,
-      ∃ Y:Silhouette p (M*n) r, i.2.2.permission → bullseye v m w i.2.2 i.2.1 ε n Y τ u from by
-       by_cases hP : i.2.2.permission
-       · obtain ⟨r,τ,u,hτ,hu,hh⟩:=glowLamp v h i.2.2 i.2.1 hP ε he
-         refine ⟨r,τ,u,hτ,hu, hh.mono (fun i hi=> ?_)⟩
-         obtain ⟨Y,hY⟩:=hi; exact ⟨Y,fun _=>hY⟩
-       exact ⟨1,1,1,zero_lt_one,zero_lt_one,.of_forall (fun n=> ⟨fun _ _ _=>0,fun hi=>(hP hi).elim⟩)⟩)
-  obtain ⟨δ,hd,hd'⟩:=minimums q hr
-  obtain ⟨e,he,he'⟩:=minimums A hq
-  refine ⟨bouquet r,δ,e,hd,he,?_⟩
-  filter_upwards [eventually_all.mpr hh] with n hn
-  choose F hF using hn
-  refine ⟨bundleY r F,fun i hi r' Y' hR τ' δ' hτ hp=> ?_⟩
-  exact hF i hi r' Y' (refines_next hR (bundle_refines r F i)) _ _ (hτ.trans (hd' _)) (hp.trans (he' _))
-
-set_option maxHeartbeats 1200000 in
-theorem lateSilk (v:Stations p M b.pins s) (h:veil p M b s0 l m s w)
-    (ε η:ℝ) (he:0<ε) (hη:0<η) (L:ℕ) :
-    ∃ (r:ℕ) (δ:ℝ),0<δ ∧ (r+1:ℝ)*δ≤η ∧ ∀ᶠ n in l,
-    ∀ Y:Silhouette p (M*n) L,∃ X:Silhouette p (M*n) r, refines X Y ∧
-      pr ((s n).sap (w n)) (fun i=>¬ gauze p δ δ X (m n) b.pins i)≤ η ∧
-      ∀ i:Scrip p b.pins,i.2.2.permission →
-         sparks (b:=b) v i m w n X ≤ ε := by
-  classical
-  obtain ⟨r,τ,u,hτ,hu,hg⟩:= twinkle v h ε he
-  let d:=r*L
-  let a:= d+1; let δ := min τ (η/(a:ℝ))
-  have hD : 0<(a:ℝ):=by unfold a; positivity
-  have hd : 0<δ:=lt_min hτ (by positivity)
-  have hb := gauzeCalendar p d M h.easel δ δ hd hd
-  refine ⟨d,δ,hd,?_,?_⟩
-  · have hh := (le_div_iff₀ hD).mp (show δ ≤ η/(a:ℝ) from min_le_right ..)
-    rw [mul_comm]; simpa [a] using hh
-  filter_upwards [hg,hb.filter_mono h.timeL,h.upright,((bp_nat_vanish (by norm_num :
-    (0:ℝ)<1/100)).eventually (eventually_le_nhds (lt_min hu hη))).filter_mono h.timeL]
-    with n hn hb hc hz Y
-  obtain ⟨X,hX⟩:=hn
-  let Z:= duoY X Y
-  have hm := (hb _ _ hc Z).trans hz
-  exact ⟨Z,(duo_good X Y).2,hm.trans (min_le_right ..),fun i h=> hX i h d Z (duo_good X Y).1
-    δ δ (min_le_left ..) (hm.trans (min_le_left ..))⟩
-end StatusAnalysis
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.AdaptiveProjectionBounds
+
+namespace OAI
+
+/-! # Simultaneous Projection -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Filter Finset Matrix
+open scoped BigOperators Topology
+namespace StatusAnalysis
+open Station PreparationParameters
+
+variable {p : Shape} {M s0 n N K : ℕ} {q:Format} {d e:Rates}
+    {l:Filter ℕ} {b:PreparationParameters} {m:cycleM p} {w:tale p M} {s:rhythms p M}
+
+def sparks (v : Stations p M b.pins s) (i:Scrip p b.pins) (m:cycleM p) (w:tale p M)
+    {r} (n:ℕ) (Y: Silhouette p (M*n) r) :=
+  Station.stratum (v n) i.2.2 (m n) (w n) i.2.1 Y
+
+def bullseye (v: Stations p M K s) (m:cycleM p) (w:tale p M) (x:Typus p q d e)
+    (k : Fin (2^deckMax p K)) (ε : ℝ) {r : ℕ} (n : ℕ) (Y : Silhouette p (M*n) r)
+    (τ u:ℝ) :=
+  ∀ (r':ℕ) (Y':Silhouette p (M*n) r'),refines Y' Y →
+  ∀ τ' δ:ℝ,τ'≤τ →
+    pr ((s n).sap (w n)) (fun i=>¬ gauze p τ' δ Y' (m n) K i) ≤u →
+    Station.stratum (v n) x (m n) (w n) k Y'≤ ε
+
+set_option maxHeartbeats 2400000 in
+theorem glowLamp (v:Stations p M b.pins s) (h:veil p M b s0 l m s w) (x:Typus p q d e)
+    (k:Fin (2^deckMax p b.pins)) (hP:x.permission) (ε:ℝ) (he:0<ε) :
+    ∃ (r : ℕ) (τ u:ℝ), 0<τ∧0<u∧∀ᶠ n in l,∃ Y:Silhouette p (M*n) r,
+      bullseye v m w x k ε n Y τ u := by
+  classical
+  have hq:=h.easel; have ht:=hq.enter.first
+  obtain ⟨z,η,hη,hX⟩:=projectCut x hP k h v ε he
+  let a:= η/(12*(z+1:ℝ))
+  have ha:0<a:=by unfold a; positivity
+  obtain ⟨i,u,c,hi,hc,hA⟩:= x.qA.sideRelease x.t x.z M hq hP.2.1 a ha
+  obtain ⟨j,v',C,hj,hC,hB⟩:= x.qB.sideRelease x.t x.z M hq hP.2.2.1 a ha
+  let f:=fun _ : Fin z=>i*j; let r:=bouquet f
+  let τ:= min u v'
+  refine ⟨r,τ,a,lt_min hi hj,ha,?_⟩
+  have hz:= (trend_sizes l h.timeL ht.hM).2
+  filter_upwards [hX,h.upright,h.durableS.shape,h.durableS.mass.positive,h.moment,
+    hA.filter_mono h.timeL,hB.filter_mono h.timeL,
+    ((bp_nat_vanish hc).eventually (eventually_le_nhds ha)).filter_mono h.timeL,
+    ((bp_nat_vanish hC).eventually (eventually_le_nhds ha)).filter_mono h.timeL,
+    hz.eventually (eventually_ge_atTop (2*num (Messenger q×Toast p)+1))]
+    with n hn ha' hB' hW he' hA hB hM hV hG
+  let N:=M*n; let p0:=s n
+  obtain ⟨P,hP'⟩:=hn
+  let e k y:=ind (P y=k)
+  have heq k y : |e k y| ≤1 := by unfold e; rw [abs_of_nonneg (ind_nonneg _)]; exact ind_le_one _
+  choose X hF using fun i:Fin z=> hA (e i) (heq i)
+  choose Z hF' using fun i:Fin z=> hB (e i) (heq i)
+  let Y k:=duoY (X k) (Z k)
+  refine ⟨bundleY f Y,fun r Y' hR τ' δ hτ hpos=>?_⟩
+  apply hP' r Y'
+  have hw:=he'.1.law
+  let hh:=hB'.1
+  have hx' i : IsLaw (x.qA.policies x.t x.z n i) :=
+    Appearance.witLaw (x.qA.allure_apt _ _ hP.2.1 _) ht.hR ha'.age
+  have hy' i : IsLaw (x.qB.policies x.t x.z n i) :=
+    Appearance.witLaw (x.qB.allure_apt _ _ hP.2.2.1 _) ht.hR ha'.age
+  have hN:= show 2*num (Messenger q×Toast p)-(N:ℝ) ≤ -1 from by
+    change _ ≤ (N:ℝ) at hG; linarith only [hG]
+  have hp := nuLaw x.t x.z hN
+  have ht' : ∀ i:Fin z,refines Y' (Y i) := fun i=> refines_next hR (bundle_refines f Y i)
+  refine (projectSum (v n) x (m n) k (w n) Y' P hh.part hw (fun i hi=>(hh.leaf i hi).pos)
+    hW hx' hy' hp a u v' τ' a δ ha.le hP ⟨hτ.trans (min_le_left ..),hτ.trans (min_le_right ..)⟩
+    hpos (fun i=>?_) (fun i=>?_)).trans ?_
+  · exact (hF i _ Y' (refines_next (ht' i) (duo_good ..).1) _ _ ha').trans hM
+  · exact (hF' i _ Y' (refines_next (ht' i) (duo_good ..).2) _ _ ha').trans hV
+  have hi : 12*(z+1:ℝ)*a=η := by unfold a; field_simp
+  nlinarith only [hi,ha,(Nat.cast_nonneg z : 0≤(z:ℝ))]
+
+private theorem minimums {A:Type} [Fintype A] (x : Wgt A) (hx:∀ i,0<x i) :
+    ∃ ε : ℝ,0<ε ∧ ∀ i, ε ≤ x i := by
+  classical
+  cases isEmpty_or_nonempty A
+  next he => exact ⟨1,zero_lt_one,fun i=> (he.false i).elim⟩
+  next he =>
+    let f:= univ.image x
+    have hf : f.Nonempty := Finset.image_nonempty.mpr Finset.univ_nonempty
+    obtain ⟨i,hi,ht⟩:= mem_image.mp (Finset.min'_mem _ hf)
+    exact ⟨f.min' hf,ht ▸ hx i,fun i=>Finset.min'_le _ _ (mem_image_of_mem _ (mem_univ i))⟩
+
+set_option maxHeartbeats 1400000 in
+theorem twinkle (v:Stations p M b.pins s) (h:veil p M b s0 l m s w)
+    (ε:ℝ) (he:0<ε) :
+    ∃ (r : ℕ) (τ u:ℝ),0<τ∧0<u∧∀ᶠ n in l,∃ Y:Silhouette p (M*n) r,
+      ∀ i:Scrip p b.pins, i.2.2.permission → bullseye v m w i.2.2 i.2.1 ε n Y τ u := by
+  classical
+  choose r q A hr hq hh using
+    (fun i:Scrip p b.pins=> show ∃ (r : ℕ) (τ u:ℝ),0<τ∧0<u∧∀ᶠ n in l,
+      ∃ Y:Silhouette p (M*n) r, i.2.2.permission → bullseye v m w i.2.2 i.2.1 ε n Y τ u from by
+       by_cases hP : i.2.2.permission
+       · obtain ⟨r,τ,u,hτ,hu,hh⟩:=glowLamp v h i.2.2 i.2.1 hP ε he
+         refine ⟨r,τ,u,hτ,hu, hh.mono (fun i hi=> ?_)⟩
+         obtain ⟨Y,hY⟩:=hi; exact ⟨Y,fun _=>hY⟩
+       exact ⟨1,1,1,zero_lt_one,zero_lt_one,.of_forall (fun n=> ⟨fun _ _ _=>0,fun hi=>(hP hi).elim⟩)⟩)
+  obtain ⟨δ,hd,hd'⟩:=minimums q hr
+  obtain ⟨e,he,he'⟩:=minimums A hq
+  refine ⟨bouquet r,δ,e,hd,he,?_⟩
+  filter_upwards [eventually_all.mpr hh] with n hn
+  choose F hF using hn
+  refine ⟨bundleY r F,fun i hi r' Y' hR τ' δ' hτ hp=> ?_⟩
+  exact hF i hi r' Y' (refines_next hR (bundle_refines r F i)) _ _ (hτ.trans (hd' _)) (hp.trans (he' _))
+
+set_option maxHeartbeats 1200000 in
+theorem lateSilk (v:Stations p M b.pins s) (h:veil p M b s0 l m s w)
+    (ε η:ℝ) (he:0<ε) (hη:0<η) (L:ℕ) :
+    ∃ (r:ℕ) (δ:ℝ),0<δ ∧ (r+1:ℝ)*δ≤η ∧ ∀ᶠ n in l,
+    ∀ Y:Silhouette p (M*n) L,∃ X:Silhouette p (M*n) r, refines X Y ∧
+      pr ((s n).sap (w n)) (fun i=>¬ gauze p δ δ X (m n) b.pins i)≤ η ∧
+      ∀ i:Scrip p b.pins,i.2.2.permission →
+         sparks (b:=b) v i m w n X ≤ ε := by
+  classical
+  obtain ⟨r,τ,u,hτ,hu,hg⟩:= twinkle v h ε he
+  let d:=r*L
+  let a:= d+1; let δ := min τ (η/(a:ℝ))
+  have hD : 0<(a:ℝ):=by unfold a; positivity
+  have hd : 0<δ:=lt_min hτ (by positivity)
+  have hb := gauzeCalendar p d M h.easel δ δ hd hd
+  refine ⟨d,δ,hd,?_,?_⟩
+  · have hh := (le_div_iff₀ hD).mp (show δ ≤ η/(a:ℝ) from min_le_right ..)
+    rw [mul_comm]; simpa [a] using hh
+  filter_upwards [hg,hb.filter_mono h.timeL,h.upright,((bp_nat_vanish (by norm_num :
+    (0:ℝ)<1/100)).eventually (eventually_le_nhds (lt_min hu hη))).filter_mono h.timeL]
+    with n hn hb hc hz Y
+  obtain ⟨X,hX⟩:=hn
+  let Z:= duoY X Y
+  have hm := (hb _ _ hc Z).trans hz
+  exact ⟨Z,(duo_good X Y).2,hm.trans (min_le_right ..),fun i h=> hX i h d Z (duo_good X Y).1
+    δ δ (min_le_left ..) (hm.trans (min_le_left ..))⟩
+end StatusAnalysis
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/SinglePositionExpansion.lean

@@ -1,82 +1,82 @@
-import OAI.Combinatorics.HadwigerCounterexample.FourCornerViews
-import OAI.Combinatorics.HadwigerCounterexample.ScriptGramCorrespondence
-
-namespace OAI
-
-/-! # Single Position Expansion -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Finset Function Matrix
-open scoped BigOperators
-variable {I A B C : Type} [Fintype I] [DecidableEq I]
-variable {p : Shape} {n N : ℕ}
-variable {X : I → Type}
-
-abbrev Aside (i : I) := {j:I//j≠i}
-def chair (X : I →Type) (i:I) := Equiv.piSplitAt i X
-
-theorem chair_split (p : ∀ i,Wgt (X i)) (x : ∀ i,X i) (a : I) :
-    prodW p x = p a (x a) *
-      prodW (fun i : Aside a=>p i.val) ((chair X a x).2) := by
-  exact Fintype.prod_eq_mul_prod_subtype_ne _ _
-
-variable [∀ i,Fintype (X i)]
-set_option maxHeartbeats 600000 in
-theorem chair_weight (p : ∀ i,Wgt (X i)) (a : I) :
-    mapW (prodW p) (chair X a)= pairW (p a)
-      (prodW (fun i : Aside a=>p i.val)) := by
-  funext i
-  obtain ⟨i,rfl⟩ := (chair X a).surjective i
-  rw [mapW_equiv_val,Equiv.symm_apply_apply]; exact chair_split p i a
-
-def arm (i j : I) (x : Corn) := if j=i then x.1 else x.2
-omit [Fintype I] [∀ i,Fintype (X i)] in
-theorem chair_arm (p : (∀ i,X i)×(∀ i,X i)) (i j : I) (x : Corn) :
-    criss (chair X i) p x j=(onSide p (arm i j x)) j := by
-  rcases x with ⟨a,b⟩
-  have he := criss_pair p a b (chair X i)
-  by_cases h : j=i
-  · subst j
-    rw [arm,ite_eq_left rfl]; exact congrArg Prod.fst he
-  rw [arm,ite_eq_right h]
-  exact congr_fun (congrArg Prod.snd he) (⟨j,h⟩:Aside i)
-
-namespace Template
-variable (v : Template p I)
-
-def beyond (v : Template p I) (i : I) : Template p (Aside i) :=
-  collect p v Subtype.val
-def chairK (v : Template p I) (i : I) (N : ℕ) :
-    Keys (p:=p) v.t N ≃ (AtomKey (p:=p) (v.t i) N × Keys (p:=p) (v.beyond i).t N) :=
-  chair _ _
-def chairI (_ : Template p I) (i : I) (n : ℕ) :
-    Inputs p n I ≃ Knobs p.g n × Inputs p n (Aside i) := chair _ _
-
-omit [Fintype I] in
-theorem key_quoin (v : Template p I) (x : I) (o : UnitType p n N)
-    (p' : Inputs p n I× Inputs p n I) (c : Corn) :
-    criss (v.chairK x N) (Prod.map (v.resultKey o) (v.resultKey o) p') c=
-      v.resultKey o (criss (v.chairI x n) p' c) := by
-  classical
-  funext i; unfold resultKey
-  change criss (chair (fun i=>AtomKey (p:=p) (v.t i) N) x) _ _ i=keyOne p _ _ (lit _ _ (criss (chair (fun _=>Knobs p.g n) x) _ _ i)) _
-  rw [chair_arm _ x,chair_arm _ x]
-  cases arm x i c <;> rfl
-
-omit [Fintype I] in
-theorem key_split (v : Template p I) (x : I) (o : UnitType p n N)
-    (z : Inputs p n I) :
-    chairK v x N (v.resultKey o z) = (v.callOne x (z x) (onSide o (v.aim x)),
-      (v.beyond x).resultKey o (fun i=>z i.val)) := by
-  apply Prod.ext <;> rfl
-
-def earns (v : Template p I) (s : Script p I) (m : Mixer p n) (q : I→F)
-    (o : UnitType p n N) (x : Inputs p n I) :=
-  (v.draw x).reads s m ∧ ownPart (p:=p) v.t q (v.resultKey o x)
-end Template
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.FourCornerViews
+import OAI.Combinatorics.HadwigerCounterexample.ScriptGramCorrespondence
+
+namespace OAI
+
+/-! # Single Position Expansion -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Finset Function Matrix
+open scoped BigOperators
+variable {I A B C : Type} [Fintype I] [DecidableEq I]
+variable {p : Shape} {n N : ℕ}
+variable {X : I → Type}
+
+abbrev Aside (i : I) := {j:I//j≠i}
+def chair (X : I →Type) (i:I) := Equiv.piSplitAt i X
+
+theorem chair_split (p : ∀ i,Wgt (X i)) (x : ∀ i,X i) (a : I) :
+    prodW p x = p a (x a) *
+      prodW (fun i : Aside a=>p i.val) ((chair X a x).2) := by
+  exact Fintype.prod_eq_mul_prod_subtype_ne _ _
+
+variable [∀ i,Fintype (X i)]
+set_option maxHeartbeats 600000 in
+theorem chair_weight (p : ∀ i,Wgt (X i)) (a : I) :
+    mapW (prodW p) (chair X a)= pairW (p a)
+      (prodW (fun i : Aside a=>p i.val)) := by
+  funext i
+  obtain ⟨i,rfl⟩ := (chair X a).surjective i
+  rw [mapW_equiv_val,Equiv.symm_apply_apply]; exact chair_split p i a
+
+def arm (i j : I) (x : Corn) := if j=i then x.1 else x.2
+omit [Fintype I] [∀ i,Fintype (X i)] in
+theorem chair_arm (p : (∀ i,X i)×(∀ i,X i)) (i j : I) (x : Corn) :
+    criss (chair X i) p x j=(onSide p (arm i j x)) j := by
+  rcases x with ⟨a,b⟩
+  have he := criss_pair p a b (chair X i)
+  by_cases h : j=i
+  · subst j
+    rw [arm,ite_eq_left rfl]; exact congrArg Prod.fst he
+  rw [arm,ite_eq_right h]
+  exact congr_fun (congrArg Prod.snd he) (⟨j,h⟩:Aside i)
+
+namespace Template
+variable (v : Template p I)
+
+def beyond (v : Template p I) (i : I) : Template p (Aside i) :=
+  collect p v Subtype.val
+def chairK (v : Template p I) (i : I) (N : ℕ) :
+    Keys (p:=p) v.t N ≃ (AtomKey (p:=p) (v.t i) N × Keys (p:=p) (v.beyond i).t N) :=
+  chair _ _
+def chairI (_ : Template p I) (i : I) (n : ℕ) :
+    Inputs p n I ≃ Knobs p.g n × Inputs p n (Aside i) := chair _ _
+
+omit [Fintype I] in
+theorem key_quoin (v : Template p I) (x : I) (o : UnitType p n N)
+    (p' : Inputs p n I× Inputs p n I) (c : Corn) :
+    criss (v.chairK x N) (Prod.map (v.resultKey o) (v.resultKey o) p') c=
+      v.resultKey o (criss (v.chairI x n) p' c) := by
+  classical
+  funext i; unfold resultKey
+  change criss (chair (fun i=>AtomKey (p:=p) (v.t i) N) x) _ _ i=keyOne p _ _ (lit _ _ (criss (chair (fun _=>Knobs p.g n) x) _ _ i)) _
+  rw [chair_arm _ x,chair_arm _ x]
+  cases arm x i c <;> rfl
+
+omit [Fintype I] in
+theorem key_split (v : Template p I) (x : I) (o : UnitType p n N)
+    (z : Inputs p n I) :
+    chairK v x N (v.resultKey o z) = (v.callOne x (z x) (onSide o (v.aim x)),
+      (v.beyond x).resultKey o (fun i=>z i.val)) := by
+  apply Prod.ext <;> rfl
+
+def earns (v : Template p I) (s : Script p I) (m : Mixer p n) (q : I→F)
+    (o : UnitType p n N) (x : Inputs p n I) :=
+  (v.draw x).reads s m ∧ ownPart (p:=p) v.t q (v.resultKey o x)
+end Template
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/SingletonPhaseTests.lean

@@ -1,135 +1,135 @@
-import OAI.Combinatorics.HadwigerCounterexample.OffsetFourierBounds
-
-namespace OAI
-
-/-! # Singleton Phase Tests -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Matrix LinearMap Module Submodule Function Finset
-open scoped BigOperators
-variable {p : Shape} {n N r : ℕ} {T : Cov p N} {A : Type} [Fintype A]
-
-theorem avg_on_support {w f g : Wgt A} (h : ∀ x,0≤w x)
-    (he : ∀ x,w x≠0 → f x≤g x) : avg w f ≤ avg w g :=
-  Finset.sum_le_sum (fun x _ => by
-    by_cases hh : w x=0
-    · rw [hh,zero_mul,zero_mul]
-    exact mul_le_mul_of_nonneg_left (he x hh) (h x))
-
-namespace Bazaar
-variable (s : Bazaar p n r T)
-
-set_option maxHeartbeats 600000 in
-theorem single_pitch {w : Wgt (UnitType p n N)} {Δ}
-    (hl : s.opened Δ w) (hv : IsLaw w) (i : Bool) (R : Party)
-    (m : Mixer p n) {ε H : ℝ} (hm : IsLaw (raw m N)) (he : initCap p N m ε)
-    (hH : 0 ≤ H) (hw : bySide p w m H)
-    (hp : selPrice p r n N H ε) (ht : num (Atlas p r T) ≤ bp (0.002*N))
-    (hN : 2*num (Full p n)-N≤ -1) :
-    |pitch p Δ w (unary i) R|≤ glimpsesBill p r H+bp (-0.24*N) ∧
-    ((∀ x,w x≠0 → ∀ y,w y≠0 → glimpse p y i (src (s.ix x))) →
-      |pitch p Δ w (unary i) R|≤bp (-0.24*N)) := by
-  classical
-  let C : Sales p n r T := fun M _ y => glimpse p y i (src M)
-  have hb M G (hh : standard M) (hh' : standard G) :=
-    glimpse_prize m hH hm he hv.sub hw hl hp M G i hh hh' (C M G) (fun _ _ h => h)
-  have hf := beat_mix s hl hv (unary i) R i C (fun M => bag_rate m hH hm he hv.sub hw hl hp M i)
-    hb ht
-  have he : discard (s:=s) w C = avg w (fun x =>
-      pr w (fun y => ¬ glimpse p y i (src (s.ix x)))) := pairW_avg ..
-  rw [he] at hf
-  constructor
-  · refine hf.trans (add_le_add_left ?_ _)
-    rw [← hv.avg_const (glimpsesBill p r H)]
-    apply avg_on_support hv.nz
-    intro x hx
-    have hX := (hl x hx).1
-    exact glimpse_failure m hH hw hv.sub i hN _ r hX.2.2 (fun z =>
-      Nat.lt_add_one_iff.mp ((s.ix x).1 z).isLt)
-  intro hh
-  have hW : avg w (fun x => pr w (fun y => ¬glimpse p y i (src (s.ix x))))=0 := by
-    rw [← hv.avg_const 0]
-    refine avg_congr (fun x hx => ?_)
-    rw [← hv.avg_const 0]
-    exact avg_congr fun y hy => ind_zero (by simp [hh x hx y hy])
-  rwa [hW,zero_add] at hf
-
-def frequent (w : Wgt (UnitType p n N)) (S : Party) (j : Bool)
-    (M G : Atlas p r T) (y : UnitType p n N) :=
-  prize p N (cells G) < mapW (s.chart w G) (s.pay M G j S) (s.pay M G j S y)
-
-theorem calm_pitch {w : Wgt (UnitType p n N)} {Δ}
-    (hl : s.opened Δ w) (hv : IsLaw w) (i : Bool) (R S : Party)
-    (m : Mixer p n) {ε H : ℝ} (hm : IsLaw (raw m N)) (he : initCap p N m ε)
-    (hH : 0 ≤ H) (hw : bySide p w m H)
-    (hp : selPrice p r n N H ε) (ht : num (Atlas p r T) ≤ bp (0.002*N)) :
-    |pitch p Δ w S R| ≤ pr (pairW w w)
-      (fun x => s.frequent w S i (s.ix x.1) (s.ix x.2) x.2) + bp (-0.24*N) := by
-  classical
-  let C : Sales p n r T := fun M G y => ¬ s.frequent w S i M G y
-  have hb (M G : Atlas p r T) (hh : standard M) (hh' : standard G) :
-      ∀ y,mapW (subW (s.chart w G) (C M G)) (s.pay M G i S) y ≤ prize p N (cells G) := by
-    let v := s.chart w G
-    let J := s.pay M G i S
-    have hw' : SubLaw v := subLaw_sub hv.sub _
-    intro y
-    by_cases he : mapW v J y≤prize p N (cells G)
-    · exact (pr_mono_left (subW_le hw'.nz _) _).trans he
-    change pr (subW v (C M G)) (fun x => J x=y) ≤ _
-    rw [pr_sub]
-    have hx : (fun x => C M G x ∧ J x=y)=(fun _ => False) := by
-      funext x
-      refine propext (iff_false_intro (fun ⟨h,h'⟩ => he ?_))
-      rw [← h']
-      exact le_of_not_gt h
-    rw [hx,pr_false]; exact (bp_pos _).le
-  have hf := beat_mix s hl hv S R i C (fun M => bag_rate m hH hm he hv.sub hw hl hp M i) hb ht
-  unfold discard C at hf; simpa only [not_not] using hf
-
-/-- fixed companion Z restrict frequent pair to this list of small Φ values -/
-def bids (w : Wgt (UnitType p n N)) (S : Party) (i : Bool)
-    (M G : Atlas p r T) (Z : Batch G N) : Finset (Batch M N) :=
-  open scoped Classical in
-  Finset.univ.filter (fun x => prize p N (cells G)<mapW (s.chart w G) (s.pay M G i S) (x,Z))
-
-theorem bids_mem (w : Wgt (UnitType p n N)) (S : Party) (i : Bool)
-    (M G : Atlas p r T) (x : UnitType p n N) :
-    s.frequent w S i M G x ↔
-      thermal p x S (src M) ∈ s.bids w S i M G (s.bag G i x) := by
-  classical
-  simp only [bids,Finset.mem_filter,Finset.mem_univ,true_and]
-  rfl
-
-theorem bids_bound {w : Wgt (UnitType p n N)} (S : Party) (i : Bool)
-    (M G : Atlas p r T) (Z : Batch G N) (hw : SubLaw w)
-    (h : ∀ x,mapW (s.chart w G) (s.bag G i) x ≤ loseA p N (cells G) 0) :
-    (↑(s.bids w S i M G Z).card:ℝ) ≤ bp (0.51*N) := by
-  classical
-  let f := s.pay M G i S
-  let v := s.chart w G
-  have hv : SubLaw v := subLaw_sub hw _
-  let B := s.bids w S i M G Z
-  let P := prize p N (cells G)
-  have he (x) (hx : x∈B) : P���mapW v f (x,Z) := (Finset.mem_filter.mp hx).2.le
-  have hg : ↑B.card * P ≤ loseA p N (cells G) 0 := by
-    have hZ : ∑ x : Batch M N,mapW v f (x,Z)=mapW v (s.bag G i) Z := by
-      let T := fun x => (f x).1
-      have hh (x : Batch M N) : (fun y => f y=(x,Z))=
-          fun y => s.bag G i y=Z ∧ T y=x := by ext y; simp [Prod.mk.injEq,f,T,pay,and_comm]
-      simp only [mapW,hh,sum_pr_tag]
-    calc ↑B.card * P = ∑ x ∈ B,P := (by simp)
-         _ ≤ ∑ x∈B,mapW v f (x,Z) := Finset.sum_le_sum he
-         _ ≤ ∑ x : Batch M N,mapW v f (x,Z) := Finset.sum_le_sum_of_subset_of_nonneg
-           (Finset.subset_univ B) (fun i _ _ => pr_nonneg hv.nz)
-         _ ≤ loseA p N (cells G) 0 := hZ.trans_le (h Z)
-  refine (le_of_mul_le_mul_right (hg.trans_eq ?_) (bp_pos _ : 0<P))
-  unfold P prize loseA
-  rw [← bp_add]; congr 1; push_cast; ring
-
-end Bazaar
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.OffsetFourierBounds
+
+namespace OAI
+
+/-! # Singleton Phase Tests -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Matrix LinearMap Module Submodule Function Finset
+open scoped BigOperators
+variable {p : Shape} {n N r : ℕ} {T : Cov p N} {A : Type} [Fintype A]
+
+theorem avg_on_support {w f g : Wgt A} (h : ∀ x,0≤w x)
+    (he : ∀ x,w x≠0 → f x≤g x) : avg w f ≤ avg w g :=
+  Finset.sum_le_sum (fun x _ => by
+    by_cases hh : w x=0
+    · rw [hh,zero_mul,zero_mul]
+    exact mul_le_mul_of_nonneg_left (he x hh) (h x))
+
+namespace Bazaar
+variable (s : Bazaar p n r T)
+
+set_option maxHeartbeats 600000 in
+theorem single_pitch {w : Wgt (UnitType p n N)} {Δ}
+    (hl : s.opened Δ w) (hv : IsLaw w) (i : Bool) (R : Party)
+    (m : Mixer p n) {ε H : ℝ} (hm : IsLaw (raw m N)) (he : initCap p N m ε)
+    (hH : 0 ≤ H) (hw : bySide p w m H)
+    (hp : selPrice p r n N H ε) (ht : num (Atlas p r T) ≤ bp (0.002*N))
+    (hN : 2*num (Full p n)-N≤ -1) :
+    |pitch p Δ w (unary i) R|≤ glimpsesBill p r H+bp (-0.24*N) ∧
+    ((∀ x,w x≠0 → ∀ y,w y≠0 → glimpse p y i (src (s.ix x))) →
+      |pitch p Δ w (unary i) R|≤bp (-0.24*N)) := by
+  classical
+  let C : Sales p n r T := fun M _ y => glimpse p y i (src M)
+  have hb M G (hh : standard M) (hh' : standard G) :=
+    glimpse_prize m hH hm he hv.sub hw hl hp M G i hh hh' (C M G) (fun _ _ h => h)
+  have hf := beat_mix s hl hv (unary i) R i C (fun M => bag_rate m hH hm he hv.sub hw hl hp M i)
+    hb ht
+  have he : discard (s:=s) w C = avg w (fun x =>
+      pr w (fun y => ¬ glimpse p y i (src (s.ix x)))) := pairW_avg ..
+  rw [he] at hf
+  constructor
+  · refine hf.trans (add_le_add_left ?_ _)
+    rw [← hv.avg_const (glimpsesBill p r H)]
+    apply avg_on_support hv.nz
+    intro x hx
+    have hX := (hl x hx).1
+    exact glimpse_failure m hH hw hv.sub i hN _ r hX.2.2 (fun z =>
+      Nat.lt_add_one_iff.mp ((s.ix x).1 z).isLt)
+  intro hh
+  have hW : avg w (fun x => pr w (fun y => ¬glimpse p y i (src (s.ix x))))=0 := by
+    rw [← hv.avg_const 0]
+    refine avg_congr (fun x hx => ?_)
+    rw [← hv.avg_const 0]
+    exact avg_congr fun y hy => ind_zero (by simp [hh x hx y hy])
+  rwa [hW,zero_add] at hf
+
+def frequent (w : Wgt (UnitType p n N)) (S : Party) (j : Bool)
+    (M G : Atlas p r T) (y : UnitType p n N) :=
+  prize p N (cells G) < mapW (s.chart w G) (s.pay M G j S) (s.pay M G j S y)
+
+theorem calm_pitch {w : Wgt (UnitType p n N)} {Δ}
+    (hl : s.opened Δ w) (hv : IsLaw w) (i : Bool) (R S : Party)
+    (m : Mixer p n) {ε H : ℝ} (hm : IsLaw (raw m N)) (he : initCap p N m ε)
+    (hH : 0 ≤ H) (hw : bySide p w m H)
+    (hp : selPrice p r n N H ε) (ht : num (Atlas p r T) ≤ bp (0.002*N)) :
+    |pitch p Δ w S R| ≤ pr (pairW w w)
+      (fun x => s.frequent w S i (s.ix x.1) (s.ix x.2) x.2) + bp (-0.24*N) := by
+  classical
+  let C : Sales p n r T := fun M G y => ¬ s.frequent w S i M G y
+  have hb (M G : Atlas p r T) (hh : standard M) (hh' : standard G) :
+      ∀ y,mapW (subW (s.chart w G) (C M G)) (s.pay M G i S) y ≤ prize p N (cells G) := by
+    let v := s.chart w G
+    let J := s.pay M G i S
+    have hw' : SubLaw v := subLaw_sub hv.sub _
+    intro y
+    by_cases he : mapW v J y≤prize p N (cells G)
+    · exact (pr_mono_left (subW_le hw'.nz _) _).trans he
+    change pr (subW v (C M G)) (fun x => J x=y) ≤ _
+    rw [pr_sub]
+    have hx : (fun x => C M G x ∧ J x=y)=(fun _ => False) := by
+      funext x
+      refine propext (iff_false_intro (fun ⟨h,h'⟩ => he ?_))
+      rw [← h']
+      exact le_of_not_gt h
+    rw [hx,pr_false]; exact (bp_pos _).le
+  have hf := beat_mix s hl hv S R i C (fun M => bag_rate m hH hm he hv.sub hw hl hp M i) hb ht
+  unfold discard C at hf; simpa only [not_not] using hf
+
+/-- fixed companion Z restrict frequent pair to this list of small Φ values -/
+def bids (w : Wgt (UnitType p n N)) (S : Party) (i : Bool)
+    (M G : Atlas p r T) (Z : Batch G N) : Finset (Batch M N) :=
+  open scoped Classical in
+  Finset.univ.filter (fun x => prize p N (cells G)<mapW (s.chart w G) (s.pay M G i S) (x,Z))
+
+theorem bids_mem (w : Wgt (UnitType p n N)) (S : Party) (i : Bool)
+    (M G : Atlas p r T) (x : UnitType p n N) :
+    s.frequent w S i M G x ↔
+      thermal p x S (src M) ∈ s.bids w S i M G (s.bag G i x) := by
+  classical
+  simp only [bids,Finset.mem_filter,Finset.mem_univ,true_and]
+  rfl
+
+theorem bids_bound {w : Wgt (UnitType p n N)} (S : Party) (i : Bool)
+    (M G : Atlas p r T) (Z : Batch G N) (hw : SubLaw w)
+    (h : ∀ x,mapW (s.chart w G) (s.bag G i) x ≤ loseA p N (cells G) 0) :
+    (↑(s.bids w S i M G Z).card:ℝ) ≤ bp (0.51*N) := by
+  classical
+  let f := s.pay M G i S
+  let v := s.chart w G
+  have hv : SubLaw v := subLaw_sub hw _
+  let B := s.bids w S i M G Z
+  let P := prize p N (cells G)
+  have he (x) (hx : x∈B) : P≤mapW v f (x,Z) := (Finset.mem_filter.mp hx).2.le
+  have hg : ↑B.card * P ≤ loseA p N (cells G) 0 := by
+    have hZ : ∑ x : Batch M N,mapW v f (x,Z)=mapW v (s.bag G i) Z := by
+      let T := fun x => (f x).1
+      have hh (x : Batch M N) : (fun y => f y=(x,Z))=
+          fun y => s.bag G i y=Z ∧ T y=x := by ext y; simp [Prod.mk.injEq,f,T,pay,and_comm]
+      simp only [mapW,hh,sum_pr_tag]
+    calc ↑B.card * P = ∑ x ∈ B,P := (by simp)
+         _ ≤ ∑ x∈B,mapW v f (x,Z) := Finset.sum_le_sum he
+         _ ≤ ∑ x : Batch M N,mapW v f (x,Z) := Finset.sum_le_sum_of_subset_of_nonneg
+           (Finset.subset_univ B) (fun i _ _ => pr_nonneg hv.nz)
+         _ ≤ loseA p N (cells G) 0 := hZ.trans_le (h Z)
+  refine (le_of_mul_le_mul_right (hg.trans_eq ?_) (bp_pos _ : 0<P))
+  unfold P prize loseA
+  rw [← bp_add]; congr 1; push_cast; ring
+
+end Bazaar
+end HadwigerCounterexample
+
+end
+
+end OAI

lean/OAI/Combinatorics/HadwigerCounterexample/SmallCoverBounds.lean

@@ -1,116 +1,116 @@
-import OAI.Combinatorics.HadwigerCounterexample.RelativeInjectionBounds
-
-namespace OAI
-
-/-! # Small Cover Bounds -/
-
-noncomputable section
-namespace HadwigerCounterexample
-open Matrix LinearMap Module Submodule Function Finset
-open scoped BigOperators
-variable {p : Shape} {n N : ℕ} {A B V : Type} [Fintype A] [Fintype B]
-
-def allSide : Party := fun _ => 1
-
-def cutDown (p : Shape) {n N}
-    (T : Cov p N) (Δ : UnitType p n N→ Ambient p N) (w : Wgt (UnitType p n N))
-    (x : UnitType p n N) : coverX p T :=
-  open scoped Classical in
-  if h : w x≠0 ∧ covered p T (Δ x) then ⟨_,h.2⟩ else 0
-
-def juris (p : Shape) {n N} (T : Cov p N) (x : UnitType p n N) (S : Party) :
-    Module.Dual F (coverX p T) :=
-  joinPhase p (listens p x) S ∘ₗ (coverX p T).subtype
-
-abbrev Daypair (p : Shape) {N} (T : Cov p N) :=
-  coverX p T × (Bool → Module.Dual F (coverX p T))
-
-def daypair (p : Shape) {n N}
-    (T : Cov p N) (Δ : UnitType p n N→ Ambient p N) (w : Wgt (UnitType p n N))
-    (x : UnitType p n N) : Daypair p T :=
-  (cutDown p T Δ w x,fun i => juris p T x (unary i))
-
-def shadow (p : Shape) {n N}
-    (T : Cov p N) (Δ : UnitType p n N→ Ambient p N) (w : Wgt (UnitType p n N))
-    (x y : UnitType p n N) (S : Party) :=
-  juris p T y S (cutDown p T Δ w x)
-
-theorem shadow_valid (p : Shape) {n N} (T : Cov p N)
-    (Δ : UnitType p n N→Ambient p N) {w}
-    (h : ∀ x,w x≠0 → covered p T (Δ x)) (x y : UnitType p n N) (S) (hx : w x≠0) :
-    shadow p T Δ w x y S=tone p y S (Δ x) := by
-  classical
-  unfold shadow cutDown
-  rw [dite_eq_left ⟨hx,h x hx⟩]; rfl
-
-theorem tone_vec (p : Shape) {n N} (x : UnitType p n N) (S : Party) (Δ : Ambient p N) :
-    tone p x S Δ=dotProduct S (fun i => tone p x (unary i) Δ) := by
-  classical
-  have hg (i) : tone p x (unary i) Δ=uPhase p (onSide (listens p x) i) Δ := by
-    unfold tone joinPhase unary
-    rw [Finset.sum_eq_single i]
-    · rw [Pi.single_eq_same,one_smul]
-    · intro j _ hj; simp [hj]
-    simp
-  unfold dotProduct
-  simp_rw [hg]
-  unfold tone joinPhase
-  simp
-
-theorem shadow_day (p : Shape) {n N} (T : Cov p N)
-    (Δ : UnitType p n N→Ambient p N) (w : Wgt (UnitType p n N))
-    (x y) (S : Party) :
-    shadow p T Δ w x y S =
-    dotProduct S (fun i => (daypair p T Δ w y).2 i (daypair p T Δ w x).1) :=
-  tone_vec p y _ (cutDown p T Δ w x).val
-
-theorem day_named (p : Shape) {n N} (T : Cov p N)
-    (Δ : UnitType p n N→Ambient p N)
-    (w : Wgt (UnitType p n N)) (d : ℕ) (hT : cdim p T≤d)
-    (P : Daypair p T × Daypair p T → Prop) :
-    named (fun v => P (daypair p T Δ w v.1,daypair p T Δ w v.2)) (bp (3*d*(N:ℝ))) := by
-  classical
-  let A := (coverX p T)
-  let : Finite (Module.Dual F (coverX p T)) := Finite.of_injective _ DFunLike.coe_injective
-  let : Fintype (Module.Dual F (coverX p T)) := Fintype.ofFinite _
-  have he : dim (Daypair p T) ≤ 3*d*N := by
-    unfold Daypair dim
-    rw [Module.finrank_prod, Module.finrank_pi_fintype,Fintype.sum_bool,
-      Subspace.dual_finrank_eq]
-    change dim A+(dim A+dim A)≤_
-    have h : dim A≤N*d := (cover_dim p T).trans (Nat.mul_le_mul_left N hT)
-    nlinarith
-  refine named_at (fun y x => P (daypair p T Δ w x,y)) ?_ (fun y => ⟨daypair p T Δ w y,fun x => Iff.rfl⟩)
-  rw [card_space]
-  exact bp_le (by exact_mod_cast he)
-
-variable [AddCommGroup V] [Module F V] [FiniteDimensional F V]
-
-theorem dual_matrix_rank (f : A→ V) (g : B→Module.Dual F V) :
-    (Matrix.of (fun x : A => fun y : B => g y (f x))).rank ≤ dim V := by
-  classical
-  let M := Matrix.of (fun x : A => fun y : B => g y (f x))
-  let L : V →ₗ[F] Vec B := LinearMap.pi g
-  have hi : colSp Mᵀ ≤ LinearMap.range L := by
-    rw [colSp, range_mulVecLin]
-    exact Submodule.span_le.mpr (Set.range_subset_iff.mpr fun x => ⟨f x,rfl⟩)
-  have he : dim (colSp Mᵀ) ≤ dim V := (Submodule.finrank_mono hi).trans
-    (LinearMap.finrank_range_le L)
-  rw [colSp_dim,Matrix.rank_transpose] at he
-  exact he
-
-def circus (p : Shape) {n N}
-    (T : Cov p N) (Δ : UnitType p n N→ Ambient p N) (w : Wgt (UnitType p n N)) :
-    Mat (UnitType p n N) (UnitType p n N) :=
-  Matrix.of (fun x y => shadow p T Δ w x y allSide)
-
-theorem circus_rank (p : Shape) {n N}
-    (T : Cov p N) (Δ : UnitType p n N→ Ambient p N) (w : Wgt (UnitType p n N)) :
-    (circus p T Δ w).rank≤ N*cdim p T := (dual_matrix_rank (cutDown p T Δ w)
-      (fun y => juris p T y allSide)).trans (cover_dim p T)
-
-end HadwigerCounterexample
-
-end
-
-end OAI
+import OAI.Combinatorics.HadwigerCounterexample.RelativeInjectionBounds
+
+namespace OAI
+
+/-! # Small Cover Bounds -/
+
+noncomputable section
+namespace HadwigerCounterexample
+open Matrix LinearMap Module Submodule Function Finset
+open scoped BigOperators
+variable {p : Shape} {n N : ℕ} {A B V : Type} [Fintype A] [Fintype B]
+
+def allSide : Party := fun _ => 1
+
+def cutDown (p : Shape) {n N}
+    (T : Cov p N) (Δ : UnitType p n N→ Ambient p N) (w : Wgt (UnitType p n N))
+    (x : UnitType p n N) : coverX p T :=
+  open scoped Classical in
+  if h : w x≠0 ∧ covered p T (Δ x) then ⟨_,h.2⟩ else 0
+
+def juris (p : Shape) {n N} (T : Cov p N) (x : UnitType p n N) (S : Party) :
+    Module.Dual F (coverX p T) :=
+  joinPhase p (listens p x) S ∘ₗ (coverX p T).subtype
+
+abbrev Daypair (p : Shape) {N} (T : Cov p N) :=
+  coverX p T × (Bool → Module.Dual F (coverX p T))
+
+def daypair (p : Shape) {n N}
+    (T : Cov p N) (Δ : UnitType p n N→ Ambient p N) (w : Wgt (UnitType p n N))
+    (x : UnitType p n N) : Daypair p T :=
+  (cutDown p T Δ w x,fun i => juris p T x (unary i))
+
+def shadow (p : Shape) {n N}
+    (T : Cov p N) (Δ : UnitType p n N→ Ambient p N) (w : Wgt (UnitType p n N))
+    (x y : UnitType p n N) (S : Party) :=
+  juris p T y S (cutDown p T Δ w x)
+
+theorem shadow_valid (p : Shape) {n N} (T : Cov p N)
+    (Δ : UnitType p n N→Ambient p N) {w}
+    (h : ∀ x,w x≠0 → covered p T (Δ x)) (x y : UnitType p n N) (S) (hx : w x≠0) :
+    shadow p T Δ w x y S=tone p y S (Δ x) := by
+  classical
+  unfold shadow cutDown
+  rw [dite_eq_left ⟨hx,h x hx⟩]; rfl
+
+theorem tone_vec (p : Shape) {n N} (x : UnitType p n N) (S : Party) (Δ : Ambient p N) :
+    tone p x S Δ=dotProduct S (fun i => tone p x (unary i) Δ) := by
+  classical
+  have hg (i) : tone p x (unary i) Δ=uPhase p (onSide (listens p x) i) Δ := by
+    unfold tone joinPhase unary
+    rw [Finset.sum_eq_single i]
+    · rw [Pi.single_eq_same,one_smul]
+    · intro j _ hj; simp [hj]
+    simp
+  unfold dotProduct
+  simp_rw [hg]
+  unfold tone joinPhase
+  simp
+
+theorem shadow_day (p : Shape) {n N} (T : Cov p N)
+    (Δ : UnitType p n N→Ambient p N) (w : Wgt (UnitType p n N))
+    (x y) (S : Party) :
+    shadow p T Δ w x y S =
+    dotProduct S (fun i => (daypair p T Δ w y).2 i (daypair p T Δ w x).1) :=
+  tone_vec p y _ (cutDown p T Δ w x).val
+
+theorem day_named (p : Shape) {n N} (T : Cov p N)
+    (Δ : UnitType p n N→Ambient p N)
+    (w : Wgt (UnitType p n N)) (d : ℕ) (hT : cdim p T≤d)
+    (P : Daypair p T × Daypair p T → Prop) :
+    named (fun v => P (daypair p T Δ w v.1,daypair p T Δ w v.2)) (bp (3*d*(N:ℝ))) := by
+  classical
+  let A := (coverX p T)
+  let : Finite (Module.Dual F (coverX p T)) := Finite.of_injective _ DFunLike.coe_injective
+  let : Fintype (Module.Dual F (coverX p T)) := Fintype.ofFinite _
+  have he : dim (Daypair p T) ≤ 3*d*N := by
+    unfold Daypair dim
+    rw [Module.finrank_prod, Module.finrank_pi_fintype,Fintype.sum_bool,
+      Subspace.dual_finrank_eq]
+    change dim A+(dim A+dim A)≤_
+    have h : dim A≤N*d := (cover_dim p T).trans (Nat.mul_le_mul_left N hT)
+    nlinarith
+  refine named_at (fun y x => P (daypair p T Δ w x,y)) ?_ (fun y => ⟨daypair p T Δ w y,fun x => Iff.rfl⟩)
+  rw [card_space]
+  exact bp_le (by exact_mod_cast he)
+
+variable [AddCommGroup V] [Module F V] [FiniteDimensional F V]
+
+theorem dual_matrix_rank (f : A→ V) (g : B→Module.Dual F V) :
+    (Matrix.of (fun x : A => fun y : B => g y (f x))).rank ≤ dim V := by
+  classical
+  let M := Matrix.of (fun x : A => fun y : B => g y (f x))
+  let L : V →ₗ[F] Vec B := LinearMap.pi g
+  have hi : colSp Mᵀ ≤ LinearMap.range L := by
+    rw [colSp, range_mulVecLin]
+    exact Submodule.span_le.mpr (Set.range_subset_iff.mpr fun x => ⟨f x,rfl⟩)
+  have he : dim (colSp Mᵀ) ≤ dim V := (Submodule.finrank_mono hi).trans
+    (LinearMap.finrank_range_le L)
+  rw [colSp_dim,Matrix.rank_transpose] at he
+  exact he
+
+def circus (p : Shape) {n N}
+    (T : Cov p N) (Δ : UnitType p n N→ Ambient p N) (w : Wgt (UnitType p n N)) :
+    Mat (UnitType p n N) (UnitType p n N) :=
+  Matrix.of (fun x y => shadow p T Δ w x y allSide)
+
+theorem circus_rank (p : Shape) {n N}
+    (T : Cov p N) (Δ : UnitType p n N→ Ambient p N) (w : Wgt (UnitType p n N)) :
+    (circus p T Δ w).rank≤ N*cdim p T := (dual_matrix_rank (cutDown p T Δ w)
+      (fun y => juris p T y allSide)).trans (cover_dim p T)
+
+end HadwigerCounterexample
+
+end
+
+end OAI