AFTD Auto-Formalizing Theoretical Domains

anti_ribbon_map_preserves_weight

theoremverified

For any finite diagram D : Finset (ℕ × ℕ), any standard Young tableau T on D, and any filling M : D → ℕ belonging to standardization_block T, the monomial weight tableau_weight of anti_ribbon_map T M on the anti-ribbon diagram anti_ribbon_diagram D.card (standard_young_tableau_descent_set T) equals tableau_weight D M.

Statement

theorem anti_ribbon_map_preserves_weight {D : Finset (ℕ × ℕ)} (T : StandardYoungTableau D)
    (M : D → ℕ) (hM : M ∈ standardization_block T) :
    tableau_weight (anti_ribbon_diagram D.card (standard_young_tableau_descent_set T)) (anti_ribbon_map T M) =
      tableau_weight D M
Source
arXiv:2611.07715 Theorem 4.3(2) and Section 5.1
Verified
07 Nov 2026
Axioms
Classical.choiceQuot.soundpropext
Built on 7
  • tableau_weightFor a finite diagram D : Finset (ℕ × ℕ) and a filling M : D → ℕ, tableau_weight D M is the multivariate polynomial in MvPolynomial ℕ ℤ…
  • anti_ribbon_diagramFor a positive integer N and a descent set S : Finset ℕ, the anti-ribbon diagram anti_ribbon_diagram N S is the finite set of cells in ℕ ×…
  • standard_young_tableau_descent_setFor a standard Young tableau T on D : Finset (ℕ × ℕ), the descent set standard_young_tableau_descent_set T is the subset of k ∈ Finset.Ico…
  • anti_ribbon_mapFor a standard Young tableau T on D : Finset (ℕ × ℕ) and a filling M : D → ℕ, anti_ribbon_map T M is the filling of anti_ribbon_diagram…
  • standardization_blockFor a standard Young tableau T on D : Finset (ℕ × ℕ), standardization_block T is the set of fillings M : D → ℕ satisfying M(T.box k) ≤…
  • standard_young_tableau_boxFor a standard Young tableau T on a finite diagram D : Finset (ℕ × ℕ) and an integer k with proof hk : k ∈ Finset.Icc 1 D.card,…
  • StandardYoungTableauFor a finite diagram D : Finset (ℕ × ℕ), a standard Young tableau is an equivalence toEquiv : D ≃ Finset.Icc 1 D.card from the subtype D…

Read back from the Lean

For any finite set of cells $D \subseteq \mathbb{N} \times \mathbb{N}$, any standard Young tableau $T$ on $D$ (an equivalence $T : D \simeq \{1, \dots, |D|\}$ satisfying a monotonicity condition), and any filling $M : D \to \mathbb{N}$ belonging to the standardization block of $T$ (meaning $M(T^{-1}(k)) \le M(T^{-1}(k+1))$ for all $1 \le k < |D|$ and $M(T^{-1}(k)) < M(T^{-1}(k+1))$ for all $k$ in the descent set of $T$): The tableau weight of the anti-ribbon diagram of size $|D|$ (associated with the descent set of $T$) under the filling anti_ribbon_map T M equals the tableau weight of $D$ under the filling $M$. That is, the product of multivariate variables $\prod_{p} X_{M'(p)}$ over the anti-ribbon diagram equals $\prod_{u \in D} X_{M(u)}$.

Written by a model that saw only the Lean, never the English above. If the two disagree, that is worth a challenge.

The proof, explained

The proof shows that the anti-ribbon map preserves the monomial weight by establishing an explicit bijection between the cells of the anti-ribbon diagram and the cells of the original diagram D. For each cell (r, c) in the anti-ribbon diagram, the index k = r + c - 1 recovers the preimage under the parametrization g and identifies the corresponding cell in D via the standard Young tableau T. Since the anti-ribbon filling at (r, c) evaluates to the value of M at this cell in D, reindexing the product of indeterminates over the anti-ribbon diagram along this bijection equates the two monomial weights.

  1. The anti-ribbon diagram is defined as the image under g of the interval {1, ..., |D|}, and g(k) belongs to this diagram for every k in that interval.

    Let S be the descent set of the standard Young tableau T. The map g parametrizes each index j by the row coordinate 1 + |{x ∈ {1, ..., j-1} : x ∈ S}| and column coordinate 1 + (j - 1 - |{x ∈ {1, ..., j-1} : x ∈ S}|). By definition, the anti-ribbon diagram is the image of {1, ..., |D|} under g, so for every k ∈ {1, ..., |D|}, the point g(k) belongs to the diagram by Finset.mem_image.mpr.

    lines 6–13

    uses Finset.mem_image.mpr

      set S := standard_young_tableau_descent_set T with hS
      set g : ℕ → ℕ × ℕ := fun j => (1 + ((Finset.Ico 1 j).filter (fun x => x ∈ S)).card,
            1 + (j - 1 - ((Finset.Ico 1 j).filter (fun x => x ∈ S)).card)) with hgdef
      have hanti : anti_ribbon_diagram D.card S = (Finset.Icc 1 D.card).image g := rfl
      have h_gmem : ∀ k ∈ Finset.Icc 1 D.card, g k ∈ anti_ribbon_diagram D.card S := by
        intro k hk
        rw [hanti]
        exact Finset.mem_image.mpr ⟨k, hk, rfl⟩
  2. For every index k ∈ {1, ..., |D|}, the coordinate sum of g(k) minus one equals k, that is, (g(k))₁ + (g(k))₂ - 1 = k.

    Let a be the number of descents in {1, ..., k - 1}. Since the filtered set is a subset of the interval [1, k), its cardinality a is at most (k - 1) by Finset.card_filter_le and Nat.card_Ico. By Nat.add_sub_of_le, a + (k - 1 - a) = k - 1. Substituting the definition of g, the sum of the coordinates minus one is (1 + a) + (1 + (k - 1 - a)) - 1 = k, which linear arithmetic (omega) verifies.

    lines 14–23

    uses Finset.mem_Icc.mp, Finset.card_filter_le, Nat.card_Ico, Nat.add_sub_of_le

      have h_phi_g : ∀ k ∈ Finset.Icc 1 D.card, (g k).1 + (g k).2 - 1 = k := by
        intro k hk
        have hk1 : 1 ≤ k := (Finset.mem_Icc.mp hk).1
        have hle : ((Finset.Ico 1 k).filter (fun x => x ∈ S)).card ≤ k - 1 := by
          calc ((Finset.Ico 1 k).filter (fun x => x ∈ S)).card ≤ (Finset.Ico 1 k).card := Finset.card_filter_le _ _
            _ = k - 1 := by rw [Nat.card_Ico]
        simp only [hgdef]
        set a := ((Finset.Ico 1 k).filter (fun x => x ∈ S)).card with ha
        have h1 : a + (k - 1 - a) = k - 1 := Nat.add_sub_of_le hle
        omega
  3. For every cell p = (r, c) in the anti-ribbon diagram, the quantity r + c - 1 lies in {1, ..., |D|} and satisfies g(r + c - 1) = p.

    Since p is in the anti-ribbon diagram, by Finset.mem_image there is some k ∈ {1, ..., |D|} such that g(k) = p. By the previous step, p₁ + p₂ - 1 = (g(k))₁ + (g(k))₂ - 1 = k. Substituting this identity yields both g(p₁ + p₂ - 1) = g(k) = p and p₁ + p₂ - 1 = k ∈ {1, ..., |D|}.

    lines 24–38

    uses Finset.mem_image

      have h_g_phi : ∀ p ∈ anti_ribbon_diagram D.card S, g (p.1 + p.2 - 1) = p := by
        intro p hp
        rw [hanti, Finset.mem_image] at hp
        obtain ⟨k, hk, hgk⟩ := hp
        have hpk : p.1 + p.2 - 1 = k := by
          rw [← hgk]
          exact h_phi_g k hk
        rw [hpk]; exact hgk
      have h_mem : ∀ p ∈ anti_ribbon_diagram D.card S, p.1 + p.2 - 1 ∈ Finset.Icc 1 D.card := by
        intro p hp
        rw [hanti, Finset.mem_image] at hp
        obtain ⟨k, hk, hgk⟩ := hp
        have hpk : p.1 + p.2 - 1 = k := by
          rw [← hgk]; exact h_phi_g k hk
        rw [hpk]; exact hk
  4. The map f(p) = p₁ + p₂ - 1 is a bijection from the anti-ribbon diagram to {1, ..., |D|}.

    We define f sending each cell p to p₁ + p₂ - 1, which was shown to lie in {1, ..., |D|}. If f(p) = f(q), applying g to both sides and using g(f(p)) = p and g(f(q)) = q shows p = q, proving injectivity via Subtype.ext. For surjectivity, any k ∈ {1, ..., |D|} has preimage g(k) in the diagram, since f(g(k)) = (g(k))₁ + (g(k))₂ - 1 = k.

    lines 39–54

    uses congrArg, Subtype.ext

      let f : ↥(anti_ribbon_diagram D.card S) → ↥(Finset.Icc 1 D.card) :=
        fun p => ⟨p.val.1 + p.val.2 - 1, h_mem p.val p.property⟩
      have hf_inj : Function.Injective f := by
        intro p q hpq
        have h1 : p.val.1 + p.val.2 - 1 = q.val.1 + q.val.2 - 1 := by
          have h := congrArg (Subtype.val) hpq
          simpa [f] using h
        have hgg : g (p.val.1 + p.val.2 - 1) = g (q.val.1 + q.val.2 - 1) := by rw [h1]
        rw [h_g_phi p.val p.property, h_g_phi q.val q.property] at hgg
        exact Subtype.ext hgg
      have hf_surj : Function.Surjective f := by
        intro k
        refine ⟨⟨g k.val, h_gmem k.val k.property⟩, ?_⟩
        apply Subtype.ext
        simp only [f]
        exact h_phi_g k.val k.property
  5. The bijection f induces an equivalence e between the anti-ribbon diagram and D such that the anti-ribbon filling at each cell p equals M(e(p)).

    By Equiv.ofBijective, f yields an equivalence from the anti-ribbon diagram to {1, ..., |D|}. Composing it with the inverse of the tableau equivalence T.toEquiv : D ≃ {1, ..., |D|} produces an equivalence e between the anti-ribbon diagram and D. By definition of anti_ribbon_map, because p₁ + p₂ - 1 ∈ {1, ..., |D|} holds (dif_pos), the anti-ribbon filling at p is M evaluated at the tableau box with label p₁ + p₂ - 1, which is precisely e(p).

    lines 55–66

    uses Equiv.ofBijective, dif_pos

      let e : ↥(anti_ribbon_diagram D.card S) ≃ ↥D :=
        (Equiv.ofBijective f ⟨hf_inj, hf_surj⟩).trans T.toEquiv.symm
      have he_apply : ∀ p, e p = T.toEquiv.symm (f p) := by
        intro p; rfl
      have hpoint : ∀ p : ↥(anti_ribbon_diagram D.card S), anti_ribbon_map T M p = M (e p) := by
        intro p
        have hbox : standard_young_tableau_box T (p.val.1 + p.val.2 - 1) (h_mem p.val p.property) = e p := by
          rw [he_apply]
          rfl
        simp only [anti_ribbon_map]
        rw [dif_pos (h_mem p.val p.property)]
        rw [hbox]
  6. The monomial weight of the anti-ribbon filling equals the monomial weight of the original filling M on D.

    Unfolding the definition of tableau_weight, each weight is the product of variables X_{filling(cell)} over all cells in the respective diagram. Because e is a bijection between the anti-ribbon diagram and D and the fillings agree pointwise under e, Fintype.prod_equiv reindexes the product over the anti-ribbon diagram to the product over D, establishing equality.

    lines 67–69

    uses Fintype.prod_equiv

      simp only [tableau_weight]
      exact (Fintype.prod_equiv e (fun p => MvPolynomial.X (anti_ribbon_map T M p))
        (fun u => MvPolynomial.X (M u)) (fun p => by rw [hpoint p]))
Finset.mem_image.mpr
An element b belongs to the image of a set s under f if there exists an element a in s such that f(a) = b.
Finset.mem_Icc.mp
If k belongs to the closed interval [a, b], then a ≤ k and k ≤ b.
Finset.card_filter_le
The number of elements in a finite set satisfying a predicate is at most the total size of the set.
Nat.card_Ico
The number of natural numbers in the half-open interval [a, b) is b - a.
Nat.add_sub_of_le
For natural numbers with a ≤ b, the identity a + (b - a) = b holds.
Finset.mem_image
An element b belongs to the image of s under f if and only if there exists a ∈ s with f(a) = b.
congrArg
Applying a function to equal arguments produces equal values.
Subtype.ext
Two elements of a subtype are equal if their underlying values are equal.
Equiv.ofBijective
A bijective function between types induces an equivalence (bijection).
dif_pos
A dependent if-then-else expression evaluates to its 'then' branch when the condition is satisfied.
Fintype.prod_equiv
A product over a finite type can be reindexed along an equivalence between index types without changing its value.

Written by a model (gemini-3.8-flash) from the Lean proof and the goal states Lean reported at each step. Lean verified the proof; this explanation is a reading aid and is not itself machine-checked.

Lean source view module on GitHub

/-- The anti-ribbon map preserves the monomial weight of fillings in each standardization block. -/theorem anti_ribbon_map_preserves_weight {D : Finset (ℕ × ℕ)} (T : StandardYoungTableau D)    (M : D → ℕ) (hM : M ∈ standardization_block T) :    tableau_weight (anti_ribbon_diagram D.card (standard_young_tableau_descent_set T)) (anti_ribbon_map T M) =      tableau_weight D M := by  set S := standard_young_tableau_descent_set T with hS  set g : ℕ → ℕ × ℕ := fun j => (1 + ((Finset.Ico 1 j).filter (fun x => x ∈ S)).card,        1 + (j - 1 - ((Finset.Ico 1 j).filter (fun x => x ∈ S)).card)) with hgdef  have hanti : anti_ribbon_diagram D.card S = (Finset.Icc 1 D.card).image g := rfl  have h_gmem : ∀ k ∈ Finset.Icc 1 D.card, g k ∈ anti_ribbon_diagram D.card S := by    intro k hk    rw [hanti]    exact Finset.mem_image.mpr ⟨k, hk, rfl⟩  have h_phi_g : ∀ k ∈ Finset.Icc 1 D.card, (g k).1 + (g k).2 - 1 = k := by    intro k hk    have hk1 : 1 ≤ k := (Finset.mem_Icc.mp hk).1    have hle : ((Finset.Ico 1 k).filter (fun x => x ∈ S)).card ≤ k - 1 := by      calc ((Finset.Ico 1 k).filter (fun x => x ∈ S)).card ≤ (Finset.Ico 1 k).card := Finset.card_filter_le _ _        _ = k - 1 := by rw [Nat.card_Ico]    simp only [hgdef]    set a := ((Finset.Ico 1 k).filter (fun x => x ∈ S)).card with ha    have h1 : a + (k - 1 - a) = k - 1 := Nat.add_sub_of_le hle    omega  have h_g_phi : ∀ p ∈ anti_ribbon_diagram D.card S, g (p.1 + p.2 - 1) = p := by    intro p hp    rw [hanti, Finset.mem_image] at hp    obtain ⟨k, hk, hgk⟩ := hp    have hpk : p.1 + p.2 - 1 = k := by      rw [← hgk]      exact h_phi_g k hk    rw [hpk]; exact hgk  have h_mem : ∀ p ∈ anti_ribbon_diagram D.card S, p.1 + p.2 - 1 ∈ Finset.Icc 1 D.card := by    intro p hp    rw [hanti, Finset.mem_image] at hp    obtain ⟨k, hk, hgk⟩ := hp    have hpk : p.1 + p.2 - 1 = k := by      rw [← hgk]; exact h_phi_g k hk    rw [hpk]; exact hk  let f : ↥(anti_ribbon_diagram D.card S) → ↥(Finset.Icc 1 D.card) :=    fun p => ⟨p.val.1 + p.val.2 - 1, h_mem p.val p.property⟩  have hf_inj : Function.Injective f := by    intro p q hpq    have h1 : p.val.1 + p.val.2 - 1 = q.val.1 + q.val.2 - 1 := by      have h := congrArg (Subtype.val) hpq      simpa [f] using h    have hgg : g (p.val.1 + p.val.2 - 1) = g (q.val.1 + q.val.2 - 1) := by rw [h1]    rw [h_g_phi p.val p.property, h_g_phi q.val q.property] at hgg    exact Subtype.ext hgg  have hf_surj : Function.Surjective f := by    intro k    refine ⟨⟨g k.val, h_gmem k.val k.property⟩, ?_⟩    apply Subtype.ext    simp only [f]    exact h_phi_g k.val k.property  let e : ↥(anti_ribbon_diagram D.card S) ≃ ↥D :=    (Equiv.ofBijective f ⟨hf_inj, hf_surj⟩).trans T.toEquiv.symm  have he_apply : ∀ p, e p = T.toEquiv.symm (f p) := by    intro p; rfl  have hpoint : ∀ p : ↥(anti_ribbon_diagram D.card S), anti_ribbon_map T M p = M (e p) := by    intro p    have hbox : standard_young_tableau_box T (p.val.1 + p.val.2 - 1) (h_mem p.val p.property) = e p := by      rw [he_apply]      rfl    simp only [anti_ribbon_map]    rw [dif_pos (h_mem p.val p.property)]    rw [hbox]  simp only [tableau_weight]  exact (Fintype.prod_equiv e (fun p => MvPolynomial.X (anti_ribbon_map T M p))    (fun u => MvPolynomial.X (M u)) (fun p => by rw [hpoint p]))
See it in the graphDiscuss this resultChallenge it