Physlib.StringTheory.FTheory.SU5.Quanta.TenQuanta

Imports

/-
Copyright (c) 2025 Joseph Tooby-Smith. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Joseph Tooby-Smith
-/
module

public import Physlib.Particles.SuperSymmetry.SU5.ChargeSpectrum.MinimallyAllowsTerm.OfFinset
public import Physlib.StringTheory.FTheory.SU5.Fluxes.NoExotics.Completeness

Quanta of 10d representations

i. Overview

The 10d representations of the SU(5)×U(1) carry the quantum numbers of their U(1) charges and their fluxes.

In this module we define the data structure for these quanta and properties thereof.

ii. Key results

TenQuanta is the type of quanta of 10d representations.

TenQuanta.toFluxesTen is the underlying FluxesTen of a TenQuanta.

TenQuanta.toCharges is the underlying Multiset charges of a TenQuanta.

TenQuanta.reduce is the reduction of a TenQuanta which adds together all the fluxes corresponding to the same charge (i.e. representation).

TenQuanta.liftCharges given a charge c the TenQuanta which have charge c and no exotics or zero fluxes.

TenQuanta.anomalyCoefficient is the anomaly coefficient associated with a TenQuanta.

iii. Table of contents

A. The definition of TenQuanta

A.1. The map to underlying fluxes

A.2. The map to underlying charges

A.3. The map from charges to fluxes

B. The reduction of a TenQuanta

B.1. The reduced TenQuanta has no duplicate elements

B.2. The underlying charges of the reduced TenQuanta are the deduped charges

B.3. Membership condition on the reduced TenQuanta

B.4. Filter of the reduced TenQuanta by a charge

B.5. The reduction is idempotent

B.6. Preservation of certain sums under reduction

B.7. Reduction does nothing if no duplicate charges

B.8. The charge map is preserved by reduction

B.9. A fluxes in the reduced TenQuanta is a sum of fluxes in the original TenQuanta

B.10. No exotics condition on the reduced TenQuanta

B.10.1. Number of chiral U

B.10.2. Number of anti-chiral U

B.10.3. Number of chiral Q

B.10.4. Number of anti-chiral Q

B.10.5. Number of chiral E

B.10.6. Number of anti-chiral E

B.10.7. The NoExotics condition on the reduced TenQuanta

B.11. Reduce member of FLuxesTen.elemsNoExotics

C. Decomposition of a TenQuanta into basic fluxes

C.1. Decomposition of fluxes

C.2. Decomposition of a TenQuanta (with no exotics)

C.2.1. Decomposition distributes over addition

C.2.2. Decomposition commutes with filtering charges

C.2.3. Decomposition preserves the charge map

C.2.4. Decomposition preserves the charges

C.2.5. Decomposition preserves the reduction

C.2.6. Fluxes of the decomposition of a TenQuanta

D. Lifting charges to TenQuanta

D.1. liftCharge c: multiset of ten-quanta for a finite set of charges c with no exotics

D.2. TenQuanta in liftCharge c have a finite set of charges c

D.3. TenQuanta in liftCharge c have no duplicate charges

D.4. Membership in liftCharge c iff is reduction of TenQuanta with given fluxes

D.5. TenQuanta in liftCharge c do not have zero fluxes

D.6. TenQuanta in liftCharge c have no exotics

D.7. Membership in liftCharge c iff have no exotics, no zero fluxes, and charges c

D.8. liftCharge c is preserved under a map if reduced

E. Anomaly cancellation coefficients

E.1. Anomaly coefficients of a TenQuanta

E.2. Anomaly coefficients under a map

E.3. Anomaly coefficients is preserved under reduce

iv. References

A reference for the anomaly cancellation conditions is arXiv:1401.5084.

@[expose] public section

A. The definition of `TenQuanta`

The quanta of w0d representations corresponding to a multiset of (q, M, N) for each particle. (M, N) are defined in the FluxesFive module.

abbrev TenQuanta (𝓩 : Type := ℤ) : Type := Multiset (𝓩 × Fluxes)

A.1. The map to underlying fluxes

The underlying FluxesTen from a TenQuanta.

def toFluxesTen (x : TenQuanta 𝓩) : FluxesTen := x.map Prod.snd

A.2. The map to underlying charges

The underlying Multiset charges from a TenQuanta.

def toCharges (x : TenQuanta 𝓩) : Multiset 𝓩 := x.map Prod.fst

A.3. The map from charges to fluxes

The map which takes a charge to the overall flux it corresponds to in a TenQuanta.

def toChargeMap [DecidableEq 𝓩] (x : TenQuanta 𝓩) : 𝓩 → Fluxes :=
  fun z => ((x.filter fun p => p.1 = z).map Prod.snd).sum

lemma toChargeMap_of_not_mem [DecidableEq 𝓩] (x : TenQuanta 𝓩) {z : 𝓩} (h : z ∉ x.toCharges) :
    x.toChargeMap z = 0 := by𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩z:𝓩h:z ∉ x.toCharges⊢ x.toChargeMap z = 0
  have hl : x.filter (fun p => p.1 = z) = 0 :=
    Multiset.filter_eq_nil.2 fun p hp hpz => h (hpz ▸ Multiset.mem_map_of_mem Prod.fst hp)𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩z:𝓩h:z ∉ x.toChargeshl:Multiset.filter (fun p => p.1 = z) x = 0⊢ x.toChargeMap z = 0
  simp [toChargeMap, hl]All goals completed! 🐙

B. The reduction of a `TenQuanta`

The reduce of TenQuanta is a new TenQuanta with all the fluxes corresponding to the same charge (i.e. representation) added together.

def reduce (x : TenQuanta 𝓩) : TenQuanta 𝓩 :=
  x.toCharges.dedup.map fun q10 => (q10, ((x.filter (fun f => f.1 = q10)).map (fun y => y.2)).sum)

B.1. The reduced `TenQuanta` has no duplicate elements



lemma reduce_nodup (x : TenQuanta 𝓩) : x.reduce.Nodup := by𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩⊢ Multiset.Nodup x.reduce
  rw [reduce𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩⊢ (Multiset.map (fun q10 => (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x)).sum))
    x.toCharges.dedup).Nodup𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩⊢ (Multiset.map (fun q10 => (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x)).sum))
    x.toCharges.dedup).Nodup]𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩⊢ (Multiset.map (fun q10 => (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x)).sum))
    x.toCharges.dedup).Nodup
  exact Multiset.Nodup.map (fun _ _ h => congrArg Prod.fst h) (Multiset.nodup_dedup _)All goals completed! 🐙

@[simp]
lemma reduce_dedup (x : TenQuanta 𝓩) : x.reduce.dedup = x.reduce :=
  Multiset.Nodup.dedup x.reduce_nodup

B.2. The underlying charges of the reduced `TenQuanta` are the deduped charges

lemma reduce_toCharges (x : TenQuanta 𝓩) : x.reduce.toCharges = x.toCharges.dedup := by𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩⊢ x.reduce.toCharges = x.toCharges.dedup
  simp [reduce, toCharges]All goals completed! 🐙

B.3. Membership condition on the reduced `TenQuanta`



lemma mem_reduce_iff (x : TenQuanta 𝓩) (p : 𝓩 × Fluxes) :
    p ∈ x.reduce ↔ p.1 ∈ x.toCharges ∧
      p.2 = ((x.filter (fun f => f.1 = p.1)).map (fun y => y.2)).sum := by𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩p:𝓩 × Fluxes⊢ p ∈ x.reduce ↔ p.1 ∈ x.toCharges ∧ p.2 = (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = p.1) x)).sum
  simp [reduce]𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩p:𝓩 × Fluxes⊢ (∃ a ∈ x.toCharges, (a, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = a) x)).sum) = p) ↔
  p.1 ∈ x.toCharges ∧ p.2 = (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = p.1) x)).sum
  constructormp𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩p:𝓩 × Fluxes⊢ (∃ a ∈ x.toCharges, (a, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = a) x)).sum) = p) →
  p.1 ∈ x.toCharges ∧ p.2 = (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = p.1) x)).summpr𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩p:𝓩 × Fluxes⊢ p.1 ∈ x.toCharges ∧ p.2 = (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = p.1) x)).sum →
  ∃ a ∈ x.toCharges, (a, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = a) x)).sum) = p
  ·mp𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩p:𝓩 × Fluxes⊢ (∃ a ∈ x.toCharges, (a, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = a) x)).sum) = p) →
  p.1 ∈ x.toCharges ∧ p.2 = (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = p.1) x)).sum rintro ⟨q, hq, rfl⟩mp𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩hq:q ∈ x.toCharges⊢ (q, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q) x)).sum).1 ∈ x.toCharges ∧
  (q, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q) x)).sum).2 =
    (Multiset.map (fun y => y.2)
        (Multiset.filter
          (fun f => f.1 = (q, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q) x)).sum).1) x)).sum
    exact ⟨hq, rfl⟩All goals completed! 🐙
  ·mpr𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩p:𝓩 × Fluxes⊢ p.1 ∈ x.toCharges ∧ p.2 = (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = p.1) x)).sum →
  ∃ a ∈ x.toCharges, (a, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = a) x)).sum) = p rintro ⟨h1, h2⟩mpr𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩p:𝓩 × Fluxesh1:p.1 ∈ x.toChargesh2:p.2 = (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = p.1) x)).sum⊢ ∃ a ∈ x.toCharges, (a, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = a) x)).sum) = p
    exact ⟨p.1, h1, by𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩p:𝓩 × Fluxesh1:p.1 ∈ x.toChargesh2:p.2 = (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = p.1) x)).sum⊢ (p.1, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = p.1) x)).sum) = p rw [← h2𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩p:𝓩 × Fluxesh1:p.1 ∈ x.toChargesh2:p.2 = (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = p.1) x)).sum⊢ (p.1, p.2) = pAll goals completed! 🐙]All goals completed! 🐙⟩

B.4. Filter of the reduced `TenQuanta` by a charge



lemma reduce_filter (x : TenQuanta 𝓩) (q : 𝓩) (h : q ∈ x.toCharges) :
    x.reduce.filter (fun f => f.1 = q) =
    {(q, ((x.filter (fun f => f.1 = q)).map (fun y => y.2)).sum)} := by𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∈ x.toCharges⊢ Multiset.filter (fun f => f.1 = q) x.reduce =
  {(q, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q) x)).sum)}
  simp [reduce]𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∈ x.toCharges⊢ Multiset.filter (fun f => f.1 = q)
    (Multiset.map (fun q10 => (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x)).sum))
      x.toCharges.dedup) =
  {(q, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q) x)).sum)}
  rw [Multiset.filter_map𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∈ x.toCharges⊢ Multiset.map (fun q10 => (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x)).sum))
    (Multiset.filter
      ((fun f => f.1 = q) ∘ fun q10 =>
        (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x)).sum))
      x.toCharges.dedup) =
  {(q, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q) x)).sum)}𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∈ x.toCharges⊢ Multiset.map (fun q10 => (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x)).sum))
    (Multiset.filter
      ((fun f => f.1 = q) ∘ fun q10 =>
        (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x)).sum))
      x.toCharges.dedup) =
  {(q, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q) x)).sum)}]𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∈ x.toCharges⊢ Multiset.map (fun q10 => (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x)).sum))
    (Multiset.filter
      ((fun f => f.1 = q) ∘ fun q10 =>
        (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x)).sum))
      x.toCharges.dedup) =
  {(q, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q) x)).sum)}
  simp only [Function.comp_apply]𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∈ x.toCharges⊢ Multiset.map (fun q10 => (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x)).sum))
    (Multiset.filter (fun x => x = q) x.toCharges.dedup) =
  {(q, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q) x)).sum)}
  have hx : (Multiset.filter (fun x => x = q) x.toCharges.dedup) = {q} := by𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∈ x.toCharges⊢ Multiset.filter (fun f => f.1 = q) x.reduce =
  {(q, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q) x)).sum)}𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∈ x.toChargeshx:Multiset.filter (fun x => x = q) x.toCharges.dedup = {q}⊢ Multiset.map (fun q10 => (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x)).sum))
    (Multiset.filter (fun x => x = q) x.toCharges.dedup) =
  {(q, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q) x)).sum)}
    rw [Multiset.filter_eq',𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∈ x.toCharges⊢ Multiset.replicate (Multiset.count q x.toCharges.dedup) q = {q}𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∈ x.toChargeshx:Multiset.filter (fun x => x = q) x.toCharges.dedup = {q}⊢ Multiset.map (fun q10 => (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x)).sum))
    (Multiset.filter (fun x => x = q) x.toCharges.dedup) =
  {(q, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q) x)).sum)} Multiset.count_dedup,𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∈ x.toCharges⊢ Multiset.replicate (if q ∈ x.toCharges then 1 else 0) q = {q}𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∈ x.toChargeshx:Multiset.filter (fun x => x = q) x.toCharges.dedup = {q}⊢ Multiset.map (fun q10 => (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x)).sum))
    (Multiset.filter (fun x => x = q) x.toCharges.dedup) =
  {(q, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q) x)).sum)} if_pos h,𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∈ x.toCharges⊢ Multiset.replicate 1 q = {q}𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∈ x.toChargeshx:Multiset.filter (fun x => x = q) x.toCharges.dedup = {q}⊢ Multiset.map (fun q10 => (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x)).sum))
    (Multiset.filter (fun x => x = q) x.toCharges.dedup) =
  {(q, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q) x)).sum)} Multiset.replicate_one𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∈ x.toCharges⊢ {q} = {q}𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∈ x.toChargeshx:Multiset.filter (fun x => x = q) x.toCharges.dedup = {q}⊢ Multiset.map (fun q10 => (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x)).sum))
    (Multiset.filter (fun x => x = q) x.toCharges.dedup) =
  {(q, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q) x)).sum)}]𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∈ x.toChargeshx:Multiset.filter (fun x => x = q) x.toCharges.dedup = {q}⊢ Multiset.map (fun q10 => (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x)).sum))
    (Multiset.filter (fun x => x = q) x.toCharges.dedup) =
  {(q, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q) x)).sum)}𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∈ x.toChargeshx:Multiset.filter (fun x => x = q) x.toCharges.dedup = {q}⊢ Multiset.map (fun q10 => (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x)).sum))
    (Multiset.filter (fun x => x = q) x.toCharges.dedup) =
  {(q, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q) x)).sum)}
  rw [hx𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∈ x.toChargeshx:Multiset.filter (fun x => x = q) x.toCharges.dedup = {q}⊢ Multiset.map (fun q10 => (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x)).sum)) {q} =
  {(q, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q) x)).sum)}𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∈ x.toChargeshx:Multiset.filter (fun x => x = q) x.toCharges.dedup = {q}⊢ Multiset.map (fun q10 => (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x)).sum)) {q} =
  {(q, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q) x)).sum)}]𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∈ x.toChargeshx:Multiset.filter (fun x => x = q) x.toCharges.dedup = {q}⊢ Multiset.map (fun q10 => (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x)).sum)) {q} =
  {(q, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q) x)).sum)}
  simpAll goals completed! 🐙

B.5. The reduction is idempotent



@[simp]
lemma reduce_reduce (x : TenQuanta 𝓩) :
    x.reduce.reduce = x.reduce := by𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩⊢ x.reduce.reduce = x.reduce
  refine Multiset.Nodup.toFinset_inj (reduce_nodup x.reduce) (reduce_nodup x) ?_𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩⊢ Multiset.toFinset x.reduce.reduce = Multiset.toFinset x.reduce
  ext p𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩p:𝓩 × Fluxes⊢ p ∈ Multiset.toFinset x.reduce.reduce ↔ p ∈ Multiset.toFinset x.reduce
  simp only [Multiset.mem_toFinset]𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩p:𝓩 × Fluxes⊢ p ∈ x.reduce.reduce ↔ p ∈ x.reduce
  rw [mem_reduce_iff,𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩p:𝓩 × Fluxes⊢ p.1 ∈ x.reduce.toCharges ∧ p.2 = (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = p.1) x.reduce)).sum ↔
  p ∈ x.reduce𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩p:𝓩 × Fluxes⊢ p.1 ∈ x.toCharges.dedup ∧ p.2 = (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = p.1) x.reduce)).sum ↔
  p.1 ∈ x.toCharges ∧ p.2 = (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = p.1) x)).sum reduce_toCharges,𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩p:𝓩 × Fluxes⊢ p.1 ∈ x.toCharges.dedup ∧ p.2 = (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = p.1) x.reduce)).sum ↔
  p ∈ x.reduce𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩p:𝓩 × Fluxes⊢ p.1 ∈ x.toCharges.dedup ∧ p.2 = (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = p.1) x.reduce)).sum ↔
  p.1 ∈ x.toCharges ∧ p.2 = (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = p.1) x)).sum mem_reduce_iff𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩p:𝓩 × Fluxes⊢ p.1 ∈ x.toCharges.dedup ∧ p.2 = (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = p.1) x.reduce)).sum ↔
  p.1 ∈ x.toCharges ∧ p.2 = (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = p.1) x)).sum𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩p:𝓩 × Fluxes⊢ p.1 ∈ x.toCharges.dedup ∧ p.2 = (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = p.1) x.reduce)).sum ↔
  p.1 ∈ x.toCharges ∧ p.2 = (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = p.1) x)).sum]𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩p:𝓩 × Fluxes⊢ p.1 ∈ x.toCharges.dedup ∧ p.2 = (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = p.1) x.reduce)).sum ↔
  p.1 ∈ x.toCharges ∧ p.2 = (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = p.1) x)).sum
  simp only [Multiset.mem_dedup, and_congr_right_iff]𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩p:𝓩 × Fluxes⊢ p.1 ∈ x.toCharges →
  (p.2 = (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = p.1) x.reduce)).sum ↔
    p.2 = (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = p.1) x)).sum)
  intro hp𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩p:𝓩 × Fluxeshp:p.1 ∈ x.toCharges⊢ p.2 = (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = p.1) x.reduce)).sum ↔
  p.2 = (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = p.1) x)).sum
  rw [reduce_filter x p.1 hp,𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩p:𝓩 × Fluxeshp:p.1 ∈ x.toCharges⊢ p.2 =
    (Multiset.map (fun y => y.2)
        {(p.1, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = p.1) x)).sum)}).sum ↔
  p.2 = (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = p.1) x)).sumAll goals completed! 🐙 Multiset.map_singleton,𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩p:𝓩 × Fluxeshp:p.1 ∈ x.toCharges⊢ p.2 = {(p.1, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = p.1) x)).sum).2}.sum ↔
  p.2 = (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = p.1) x)).sumAll goals completed! 🐙 Multiset.sum_singleton𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩p:𝓩 × Fluxeshp:p.1 ∈ x.toCharges⊢ p.2 = (p.1, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = p.1) x)).sum).2 ↔
  p.2 = (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = p.1) x)).sumAll goals completed! 🐙]All goals completed! 🐙

B.6. Preservation of certain sums under reduction



lemma reduce_sum_eq_sum_toCharges {M} [AddCommMonoid M] (x : TenQuanta 𝓩) (f : 𝓩 → Fluxes →+ M) :
    (x.reduce.map fun (q, x) => f q x).sum = (x.map fun (q, x) => f q x).sum := by𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ (Multiset.map
      (fun x =>
        match x with
        | (q, x) => (f q) x)
      x.reduce).sum =
  (Multiset.map
      (fun x =>
        match x with
        | (q, x) => (f q) x)
      x).sum
  calc _
      _ = ∑ q ∈ x.toCharges.toFinset,
          f q ((x.filter (fun f => f.1 = q)).map (fun y => y.2)).sum := by𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ (Multiset.map
      (fun x =>
        match x with
        | (q, x) => (f q) x)
      x.reduce).sum =
  ∑ q ∈ x.toCharges.toFinset, (f q) (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q) x)).sum
        rw [reduce𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ (Multiset.map
      (fun x =>
        match x with
        | (q, x) => (f q) x)
      (Multiset.map (fun q10 => (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x)).sum))
        x.toCharges.dedup)).sum =
  ∑ q ∈ x.toCharges.toFinset, (f q) (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q) x)).sum𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ (Multiset.map
      (fun x =>
        match x with
        | (q, x) => (f q) x)
      (Multiset.map (fun q10 => (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x)).sum))
        x.toCharges.dedup)).sum =
  ∑ q ∈ x.toCharges.toFinset, (f q) (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q) x)).sum]𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ (Multiset.map
      (fun x =>
        match x with
        | (q, x) => (f q) x)
      (Multiset.map (fun q10 => (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x)).sum))
        x.toCharges.dedup)).sum =
  ∑ q ∈ x.toCharges.toFinset, (f q) (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q) x)).sum
        simp [Finset.sum]All goals completed! 🐙
      _ = ∑ q ∈ x.toCharges.toFinset,
          (((x.filter (fun f => f.1 = q)).map (fun y => f q y.2))).sum := by𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ ∑ q ∈ x.toCharges.toFinset, (f q) (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q) x)).sum =
  ∑ q ∈ x.toCharges.toFinset, (Multiset.map (fun y => (f q) y.2) (Multiset.filter (fun f => f.1 = q) x)).sum
        congre_f𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ (fun q => (f q) (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q) x)).sum) = fun q =>
  (Multiset.map (fun y => (f q) y.2) (Multiset.filter (fun f => f.1 = q) x)).sum
        funext q5e_f𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mq5:𝓩⊢ (f q5) (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q5) x)).sum =
  (Multiset.map (fun y => (f q5) y.2) (Multiset.filter (fun f => f.1 = q5) x)).sum
        rw [AddMonoidHom.map_multiset_sum,e_f𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mq5:𝓩⊢ (Multiset.map (⇑(f q5)) (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q5) x))).sum =
  (Multiset.map (fun y => (f q5) y.2) (Multiset.filter (fun f => f.1 = q5) x)).sume_f𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mq5:𝓩⊢ (Multiset.map (⇑(f q5) ∘ fun y => y.2) (Multiset.filter (fun f => f.1 = q5) x)).sum =
  (Multiset.map (fun y => (f q5) y.2) (Multiset.filter (fun f => f.1 = q5) x)).sum Multiset.map_mape_f𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mq5:𝓩⊢ (Multiset.map (⇑(f q5) ∘ fun y => y.2) (Multiset.filter (fun f => f.1 = q5) x)).sum =
  (Multiset.map (fun y => (f q5) y.2) (Multiset.filter (fun f => f.1 = q5) x)).sume_f𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mq5:𝓩⊢ (Multiset.map (⇑(f q5) ∘ fun y => y.2) (Multiset.filter (fun f => f.1 = q5) x)).sum =
  (Multiset.map (fun y => (f q5) y.2) (Multiset.filter (fun f => f.1 = q5) x)).sum]e_f𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mq5:𝓩⊢ (Multiset.map (⇑(f q5) ∘ fun y => y.2) (Multiset.filter (fun f => f.1 = q5) x)).sum =
  (Multiset.map (fun y => (f q5) y.2) (Multiset.filter (fun f => f.1 = q5) x)).sum
        rflAll goals completed! 🐙
      _ = (x.toCharges.dedup.bind fun q =>
          ((x.filter (fun f => f.1 = q)).map (fun y => f q y.2))).sum := by𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ ∑ q ∈ x.toCharges.toFinset, (Multiset.map (fun y => (f q) y.2) (Multiset.filter (fun f => f.1 = q) x)).sum =
  (x.toCharges.dedup.bind fun q => Multiset.map (fun y => (f q) y.2) (Multiset.filter (fun f => f.1 = q) x)).sum
        rw [Multiset.sum_bind𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ ∑ q ∈ x.toCharges.toFinset, (Multiset.map (fun y => (f q) y.2) (Multiset.filter (fun f => f.1 = q) x)).sum =
  (Multiset.map (fun a => (Multiset.map (fun y => (f a) y.2) (Multiset.filter (fun f => f.1 = a) x)).sum)
      x.toCharges.dedup).sum𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ ∑ q ∈ x.toCharges.toFinset, (Multiset.map (fun y => (f q) y.2) (Multiset.filter (fun f => f.1 = q) x)).sum =
  (Multiset.map (fun a => (Multiset.map (fun y => (f a) y.2) (Multiset.filter (fun f => f.1 = a) x)).sum)
      x.toCharges.dedup).sum]𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ ∑ q ∈ x.toCharges.toFinset, (Multiset.map (fun y => (f q) y.2) (Multiset.filter (fun f => f.1 = q) x)).sum =
  (Multiset.map (fun a => (Multiset.map (fun y => (f a) y.2) (Multiset.filter (fun f => f.1 = a) x)).sum)
      x.toCharges.dedup).sum
        simp [Finset.sum]All goals completed! 🐙
      _ = (((x.toCharges.dedup.bind fun q =>
          ((x.filter (fun f => f.1 = q)))).map (fun y => f y.1 y.2))).sum := by𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ (x.toCharges.dedup.bind fun q => Multiset.map (fun y => (f q) y.2) (Multiset.filter (fun f => f.1 = q) x)).sum =
  (Multiset.map (fun y => (f y.1) y.2) (x.toCharges.dedup.bind fun q => Multiset.filter (fun f => f.1 = q) x)).sum
        congr𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ (x.toCharges.dedup.bind fun q => Multiset.map (fun y => (f q) y.2) (Multiset.filter (fun f => f.1 = q) x)) =
  Multiset.map (fun y => (f y.1) y.2) (x.toCharges.dedup.bind fun q => Multiset.filter (fun f => f.1 = q) x)
        rw [Multiset.map_bind𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ (x.toCharges.dedup.bind fun q => Multiset.map (fun y => (f q) y.2) (Multiset.filter (fun f => f.1 = q) x)) =
  x.toCharges.dedup.bind fun a => Multiset.map (fun y => (f y.1) y.2) (Multiset.filter (fun f => f.1 = a) x)𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ (x.toCharges.dedup.bind fun q => Multiset.map (fun y => (f q) y.2) (Multiset.filter (fun f => f.1 = q) x)) =
  x.toCharges.dedup.bind fun a => Multiset.map (fun y => (f y.1) y.2) (Multiset.filter (fun f => f.1 = a) x)]𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ (x.toCharges.dedup.bind fun q => Multiset.map (fun y => (f q) y.2) (Multiset.filter (fun f => f.1 = q) x)) =
  x.toCharges.dedup.bind fun a => Multiset.map (fun y => (f y.1) y.2) (Multiset.filter (fun f => f.1 = a) x)
        congre_f𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ (fun q => Multiset.map (fun y => (f q) y.2) (Multiset.filter (fun f => f.1 = q) x)) = fun a =>
  Multiset.map (fun y => (f y.1) y.2) (Multiset.filter (fun f => f.1 = a) x)
        funext qe_f𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mq:𝓩⊢ Multiset.map (fun y => (f q) y.2) (Multiset.filter (fun f => f.1 = q) x) =
  Multiset.map (fun y => (f y.1) y.2) (Multiset.filter (fun f => f.1 = q) x)
        refine Multiset.map_congr rfl ?_e_f𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mq:𝓩⊢ ∀ x_1 ∈ Multiset.filter (fun f => f.1 = q) x, (f q) x_1.2 = (f x_1.1) x_1.2
        intro y hye_f𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mq:𝓩y:𝓩 × Fluxeshy:y ∈ Multiset.filter (fun f => f.1 = q) x⊢ (f q) y.2 = (f y.1) y.2
        simp at hye_f𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mq:𝓩y:𝓩 × Fluxeshy:y ∈ x ∧ y.1 = q⊢ (f q) y.2 = (f y.1) y.2
        rw [hy.2e_f𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mq:𝓩y:𝓩 × Fluxeshy:y ∈ x ∧ y.1 = q⊢ (f q) y.2 = (f q) y.2All goals completed! 🐙]All goals completed! 🐙
      _ = ((x.map (fun y => f y.1 y.2))).sum := by𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ (Multiset.map (fun y => (f y.1) y.2) (x.toCharges.dedup.bind fun q => Multiset.filter (fun f => f.1 = q) x)).sum =
  (Multiset.map (fun y => (f y.1) y.2) x).sum
        congre_s𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ (x.toCharges.dedup.bind fun q => Multiset.filter (fun f => f.1 = q) x) = x
        apply Multiset.ext.mpre_s𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ ∀ (a : 𝓩 × Fluxes),
  Multiset.count a (x.toCharges.dedup.bind fun q => Multiset.filter (fun f => f.1 = q) x) = Multiset.count a x
        intro pe_s𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxes⊢ Multiset.count p (x.toCharges.dedup.bind fun q => Multiset.filter (fun f => f.1 = q) x) = Multiset.count p x
        trans ((x.map Prod.fst).dedup.map (fun y => if p.1 = y then x.count p else 0)).sum𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxes⊢ Multiset.count p (x.toCharges.dedup.bind fun q => Multiset.filter (fun f => f.1 = q) x) =
  (Multiset.map (fun y => if p.1 = y then Multiset.count p x else 0) (Multiset.map Prod.fst x).dedup).sum𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxes⊢ (Multiset.map (fun y => if p.1 = y then Multiset.count p x else 0) (Multiset.map Prod.fst x).dedup).sum =
  Multiset.count p x
        ·𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxes⊢ Multiset.count p (x.toCharges.dedup.bind fun q => Multiset.filter (fun f => f.1 = q) x) =
  (Multiset.map (fun y => if p.1 = y then Multiset.count p x else 0) (Multiset.map Prod.fst x).dedup).sum rw [@Multiset.count_bind𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxes⊢ (Multiset.map (fun b => Multiset.count p (Multiset.filter (fun f => f.1 = b) x)) x.toCharges.dedup).sum =
  (Multiset.map (fun y => if p.1 = y then Multiset.count p x else 0) (Multiset.map Prod.fst x).dedup).sum𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxes⊢ (Multiset.map (fun b => Multiset.count p (Multiset.filter (fun f => f.1 = b) x)) x.toCharges.dedup).sum =
  (Multiset.map (fun y => if p.1 = y then Multiset.count p x else 0) (Multiset.map Prod.fst x).dedup).sum]𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxes⊢ (Multiset.map (fun b => Multiset.count p (Multiset.filter (fun f => f.1 = b) x)) x.toCharges.dedup).sum =
  (Multiset.map (fun y => if p.1 = y then Multiset.count p x else 0) (Multiset.map Prod.fst x).dedup).sum
          congre_f𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxes⊢ (fun b => Multiset.count p (Multiset.filter (fun f => f.1 = b) x)) = fun y => if p.1 = y then Multiset.count p x else 0
          funext q5e_f𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesq5:𝓩⊢ Multiset.count p (Multiset.filter (fun f => f.1 = q5) x) = if p.1 = q5 then Multiset.count p x else 0
          rw [Multiset.count_filtere_f𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesq5:𝓩⊢ (if p.1 = q5 then Multiset.count p x else 0) = if p.1 = q5 then Multiset.count p x else 0All goals completed! 🐙]All goals completed! 🐙
        by_cases h_mem : p.1 ∈ x.map Prod.fstpos𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∈ Multiset.map Prod.fst x⊢ (Multiset.map (fun y => if p.1 = y then Multiset.count p x else 0) (Multiset.map Prod.fst x).dedup).sum =
  Multiset.count p xneg𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∉ Multiset.map Prod.fst x⊢ (Multiset.map (fun y => if p.1 = y then Multiset.count p x else 0) (Multiset.map Prod.fst x).dedup).sum =
  Multiset.count p x
        ·pos𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∈ Multiset.map Prod.fst x⊢ (Multiset.map (fun y => if p.1 = y then Multiset.count p x else 0) (Multiset.map Prod.fst x).dedup).sum =
  Multiset.count p x have h_mem_dedup : p.1 ∈ (x.map Prod.fst).dedup := by𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ (Multiset.map (fun y => (f y.1) y.2) (x.toCharges.dedup.bind fun q => Multiset.filter (fun f => f.1 = q) x)).sum =
  (Multiset.map (fun y => (f y.1) y.2) x).sumpos𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∈ Multiset.map Prod.fst xh_mem_dedup:p.1 ∈ (Multiset.map Prod.fst x).dedup⊢ (Multiset.map (fun y => if p.1 = y then Multiset.count p x else 0) (Multiset.map Prod.fst x).dedup).sum =
  Multiset.count p x rwa [Multiset.mem_dedup𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∈ Multiset.map Prod.fst x⊢ p.1 ∈ Multiset.map Prod.fst xpos𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∈ Multiset.map Prod.fst xh_mem_dedup:p.1 ∈ (Multiset.map Prod.fst x).dedup⊢ (Multiset.map (fun y => if p.1 = y then Multiset.count p x else 0) (Multiset.map Prod.fst x).dedup).sum =
  Multiset.count p x]𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∈ Multiset.map Prod.fst x⊢ p.1 ∈ Multiset.map Prod.fst xpos𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∈ Multiset.map Prod.fst xh_mem_dedup:p.1 ∈ (Multiset.map Prod.fst x).dedup⊢ (Multiset.map (fun y => if p.1 = y then Multiset.count p x else 0) (Multiset.map Prod.fst x).dedup).sum =
  Multiset.count p xpos𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∈ Multiset.map Prod.fst xh_mem_dedup:p.1 ∈ (Multiset.map Prod.fst x).dedup⊢ (Multiset.map (fun y => if p.1 = y then Multiset.count p x else 0) (Multiset.map Prod.fst x).dedup).sum =
  Multiset.count p x
          rw [Multiset.sum_map_eq_nsmul_single p.1pos𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∈ Multiset.map Prod.fst xh_mem_dedup:p.1 ∈ (Multiset.map Prod.fst x).dedup⊢ (Multiset.count p.1 (Multiset.map Prod.fst x).dedup • if p.1 = p.1 then Multiset.count p x else 0) = Multiset.count p xpos𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∈ Multiset.map Prod.fst xh_mem_dedup:p.1 ∈ (Multiset.map Prod.fst x).dedup⊢ ∀ (i' : 𝓩), i' ≠ p.1 → i' ∈ (Multiset.map Prod.fst x).dedup → (if p.1 = i' then Multiset.count p x else 0) = 0pos𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∈ Multiset.map Prod.fst xh_mem_dedup:p.1 ∈ (Multiset.map Prod.fst x).dedup⊢ (Multiset.count p.1 (Multiset.map Prod.fst x).dedup • if p.1 = p.1 then Multiset.count p x else 0) = Multiset.count p xpos𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∈ Multiset.map Prod.fst xh_mem_dedup:p.1 ∈ (Multiset.map Prod.fst x).dedup⊢ ∀ (i' : 𝓩), i' ≠ p.1 → i' ∈ (Multiset.map Prod.fst x).dedup → (if p.1 = i' then Multiset.count p x else 0) = 0]pos𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∈ Multiset.map Prod.fst xh_mem_dedup:p.1 ∈ (Multiset.map Prod.fst x).dedup⊢ (Multiset.count p.1 (Multiset.map Prod.fst x).dedup • if p.1 = p.1 then Multiset.count p x else 0) = Multiset.count p xpos𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∈ Multiset.map Prod.fst xh_mem_dedup:p.1 ∈ (Multiset.map Prod.fst x).dedup⊢ ∀ (i' : 𝓩), i' ≠ p.1 → i' ∈ (Multiset.map Prod.fst x).dedup → (if p.1 = i' then Multiset.count p x else 0) = 0
          simp only [↓reduceIte, smul_eq_mul]pos𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∈ Multiset.map Prod.fst xh_mem_dedup:p.1 ∈ (Multiset.map Prod.fst x).dedup⊢ Multiset.count p.1 (Multiset.map Prod.fst x).dedup * Multiset.count p x = Multiset.count p xpos𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∈ Multiset.map Prod.fst xh_mem_dedup:p.1 ∈ (Multiset.map Prod.fst x).dedup⊢ ∀ (i' : 𝓩), i' ≠ p.1 → i' ∈ (Multiset.map Prod.fst x).dedup → (if p.1 = i' then Multiset.count p x else 0) = 0
          have h_count_one : Multiset.count p.1 (Multiset.map Prod.fst x).dedup = 1 := by𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ (Multiset.map (fun y => (f y.1) y.2) (x.toCharges.dedup.bind fun q => Multiset.filter (fun f => f.1 = q) x)).sum =
  (Multiset.map (fun y => (f y.1) y.2) x).sumpos𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∈ Multiset.map Prod.fst xh_mem_dedup:p.1 ∈ (Multiset.map Prod.fst x).deduph_count_one:Multiset.count p.1 (Multiset.map Prod.fst x).dedup = 1⊢ Multiset.count p.1 (Multiset.map Prod.fst x).dedup * Multiset.count p x = Multiset.count p xpos𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∈ Multiset.map Prod.fst xh_mem_dedup:p.1 ∈ (Multiset.map Prod.fst x).dedup⊢ ∀ (i' : 𝓩), i' ≠ p.1 → i' ∈ (Multiset.map Prod.fst x).dedup → (if p.1 = i' then Multiset.count p x else 0) = 0
            refine Multiset.count_eq_one_of_mem ?_ h_mem_dedup𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∈ Multiset.map Prod.fst xh_mem_dedup:p.1 ∈ (Multiset.map Prod.fst x).dedup⊢ (Multiset.map Prod.fst x).dedup.Noduppos𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∈ Multiset.map Prod.fst xh_mem_dedup:p.1 ∈ (Multiset.map Prod.fst x).deduph_count_one:Multiset.count p.1 (Multiset.map Prod.fst x).dedup = 1⊢ Multiset.count p.1 (Multiset.map Prod.fst x).dedup * Multiset.count p x = Multiset.count p xpos𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∈ Multiset.map Prod.fst xh_mem_dedup:p.1 ∈ (Multiset.map Prod.fst x).dedup⊢ ∀ (i' : 𝓩), i' ≠ p.1 → i' ∈ (Multiset.map Prod.fst x).dedup → (if p.1 = i' then Multiset.count p x else 0) = 0
            exact Multiset.nodup_dedup (Multiset.map Prod.fst x)pos𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∈ Multiset.map Prod.fst xh_mem_dedup:p.1 ∈ (Multiset.map Prod.fst x).deduph_count_one:Multiset.count p.1 (Multiset.map Prod.fst x).dedup = 1⊢ Multiset.count p.1 (Multiset.map Prod.fst x).dedup * Multiset.count p x = Multiset.count p xpos𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∈ Multiset.map Prod.fst xh_mem_dedup:p.1 ∈ (Multiset.map Prod.fst x).dedup⊢ ∀ (i' : 𝓩), i' ≠ p.1 → i' ∈ (Multiset.map Prod.fst x).dedup → (if p.1 = i' then Multiset.count p x else 0) = 0pos𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∈ Multiset.map Prod.fst xh_mem_dedup:p.1 ∈ (Multiset.map Prod.fst x).deduph_count_one:Multiset.count p.1 (Multiset.map Prod.fst x).dedup = 1⊢ Multiset.count p.1 (Multiset.map Prod.fst x).dedup * Multiset.count p x = Multiset.count p xpos𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∈ Multiset.map Prod.fst xh_mem_dedup:p.1 ∈ (Multiset.map Prod.fst x).dedup⊢ ∀ (i' : 𝓩), i' ≠ p.1 → i' ∈ (Multiset.map Prod.fst x).dedup → (if p.1 = i' then Multiset.count p x else 0) = 0
          simp [h_count_one]pos𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∈ Multiset.map Prod.fst xh_mem_dedup:p.1 ∈ (Multiset.map Prod.fst x).dedup⊢ ∀ (i' : 𝓩), i' ≠ p.1 → i' ∈ (Multiset.map Prod.fst x).dedup → (if p.1 = i' then Multiset.count p x else 0) = 0
          intro q5' h h2pos𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∈ Multiset.map Prod.fst xh_mem_dedup:p.1 ∈ (Multiset.map Prod.fst x).dedupq5':𝓩h:q5' ≠ p.1h2:q5' ∈ (Multiset.map Prod.fst x).dedup⊢ (if p.1 = q5' then Multiset.count p x else 0) = 0
          simp_all [eq_comm]All goals completed! 🐙
        ·neg𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∉ Multiset.map Prod.fst x⊢ (Multiset.map (fun y => if p.1 = y then Multiset.count p x else 0) (Multiset.map Prod.fst x).dedup).sum =
  Multiset.count p x rw [Multiset.sum_eq_zeroneg𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∉ Multiset.map Prod.fst x⊢ 0 = Multiset.count p xneg𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∉ Multiset.map Prod.fst x⊢ ∀ x_1 ∈ Multiset.map (fun y => if p.1 = y then Multiset.count p x else 0) (Multiset.map Prod.fst x).dedup, x_1 = 0neg𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∉ Multiset.map Prod.fst x⊢ 0 = Multiset.count p xneg𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∉ Multiset.map Prod.fst x⊢ ∀ x_1 ∈ Multiset.map (fun y => if p.1 = y then Multiset.count p x else 0) (Multiset.map Prod.fst x).dedup, x_1 = 0]neg𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∉ Multiset.map Prod.fst x⊢ 0 = Multiset.count p xneg𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∉ Multiset.map Prod.fst x⊢ ∀ x_1 ∈ Multiset.map (fun y => if p.1 = y then Multiset.count p x else 0) (Multiset.map Prod.fst x).dedup, x_1 = 0
          refine Eq.symm (Multiset.count_eq_zero_of_notMem ?_)neg𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∉ Multiset.map Prod.fst x⊢ p ∉ xneg𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∉ Multiset.map Prod.fst x⊢ ∀ x_1 ∈ Multiset.map (fun y => if p.1 = y then Multiset.count p x else 0) (Multiset.map Prod.fst x).dedup, x_1 = 0
          intro hneg𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∉ Multiset.map Prod.fst xh:p ∈ x⊢ Falseneg𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∉ Multiset.map Prod.fst x⊢ ∀ x_1 ∈ Multiset.map (fun y => if p.1 = y then Multiset.count p x else 0) (Multiset.map Prod.fst x).dedup, x_1 = 0
          have h_mem : p.1 ∈ Multiset.map Prod.fst x := by𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ (Multiset.map (fun y => (f y.1) y.2) (x.toCharges.dedup.bind fun q => Multiset.filter (fun f => f.1 = q) x)).sum =
  (Multiset.map (fun y => (f y.1) y.2) x).sumneg𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem✝:p.1 ∉ Multiset.map Prod.fst xh:p ∈ xh_mem:p.1 ∈ Multiset.map Prod.fst x⊢ Falseneg𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∉ Multiset.map Prod.fst x⊢ ∀ x_1 ∈ Multiset.map (fun y => if p.1 = y then Multiset.count p x else 0) (Multiset.map Prod.fst x).dedup, x_1 = 0
            simp_allneg𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem✝:p.1 ∉ Multiset.map Prod.fst xh:p ∈ xh_mem:p.1 ∈ Multiset.map Prod.fst x⊢ Falseneg𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∉ Multiset.map Prod.fst x⊢ ∀ x_1 ∈ Multiset.map (fun y => if p.1 = y then Multiset.count p x else 0) (Multiset.map Prod.fst x).dedup, x_1 = 0neg𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem✝:p.1 ∉ Multiset.map Prod.fst xh:p ∈ xh_mem:p.1 ∈ Multiset.map Prod.fst x⊢ Falseneg𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∉ Multiset.map Prod.fst x⊢ ∀ x_1 ∈ Multiset.map (fun y => if p.1 = y then Multiset.count p x else 0) (Multiset.map Prod.fst x).dedup, x_1 = 0
          (expose_namesneg𝓩:Typeinst:DecidableEq 𝓩M:Type u_1inst_1:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem_1:p.1 ∉ Multiset.map Prod.fst xh:p ∈ xh_mem:p.1 ∈ Multiset.map Prod.fst x⊢ Falseneg𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∉ Multiset.map Prod.fst x⊢ ∀ x_1 ∈ Multiset.map (fun y => if p.1 = y then Multiset.count p x else 0) (Multiset.map Prod.fst x).dedup, x_1 = 0; exact h_mem_1 h_memneg𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∉ Multiset.map Prod.fst x⊢ ∀ x_1 ∈ Multiset.map (fun y => if p.1 = y then Multiset.count p x else 0) (Multiset.map Prod.fst x).dedup, x_1 = 0)
          intro p' hpneg𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∉ Multiset.map Prod.fst xp':ℕhp:p' ∈ Multiset.map (fun y => if p.1 = y then Multiset.count p x else 0) (Multiset.map Prod.fst x).dedup⊢ p' = 0
          simp at hpneg𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∉ Multiset.map Prod.fst xp':ℕhp:∃ a, (∃ x_1, (a, x_1) ∈ x) ∧ (if p.1 = a then Multiset.count p x else 0) = p'⊢ p' = 0
          obtain ⟨q5', ⟨f1, hf⟩, hp'⟩ := hpneg𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∉ Multiset.map Prod.fst xp':ℕq5':𝓩hp':(if p.1 = q5' then Multiset.count p x else 0) = p'f1:Fluxeshf:(q5', f1) ∈ x⊢ p' = 0
          by_cases h_eq : p.1 = q5'pos𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∉ Multiset.map Prod.fst xp':ℕq5':𝓩hp':(if p.1 = q5' then Multiset.count p x else 0) = p'f1:Fluxeshf:(q5', f1) ∈ xh_eq:p.1 = q5'⊢ p' = 0neg𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∉ Multiset.map Prod.fst xp':ℕq5':𝓩hp':(if p.1 = q5' then Multiset.count p x else 0) = p'f1:Fluxeshf:(q5', f1) ∈ xh_eq:¬p.1 = q5'⊢ p' = 0
          ·pos𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∉ Multiset.map Prod.fst xp':ℕq5':𝓩hp':(if p.1 = q5' then Multiset.count p x else 0) = p'f1:Fluxeshf:(q5', f1) ∈ xh_eq:p.1 = q5'⊢ p' = 0 simp_allAll goals completed! 🐙
          ·neg𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:TenQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∉ Multiset.map Prod.fst xp':ℕq5':𝓩hp':(if p.1 = q5' then Multiset.count p x else 0) = p'f1:Fluxeshf:(q5', f1) ∈ xh_eq:¬p.1 = q5'⊢ p' = 0 simp_allAll goals completed! 🐙

B.7. Reduction does nothing if no duplicate charges



lemma reduce_eq_self_of_ofCharges_nodup (x : TenQuanta 𝓩) (h : x.toCharges.Nodup) :
    x.reduce = x := by𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h:x.toCharges.Nodup⊢ x.reduce = x
  rw [reduce,𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h:x.toCharges.Nodup⊢ Multiset.map (fun q10 => (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x)).sum))
    x.toCharges.dedup =
  x𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h:x.toCharges.Nodup⊢ Multiset.map (fun q10 => (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x)).sum))
    x.toCharges =
  x Multiset.Nodup.dedup h𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h:x.toCharges.Nodup⊢ Multiset.map (fun q10 => (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x)).sum))
    x.toCharges =
  x𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h:x.toCharges.Nodup⊢ Multiset.map (fun q10 => (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x)).sum))
    x.toCharges =
  x]𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h:x.toCharges.Nodup⊢ Multiset.map (fun q10 => (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x)).sum))
    x.toCharges =
  x
  simp [toCharges]𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h:x.toCharges.Nodup⊢ Multiset.map (fun x_1 => (x_1.1, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = x_1.1) x)).sum)) x = x
  conv_rhs => rw [← Multiset.map_id x]𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h:x.toCharges.Nodup| Multiset.map id x
  apply Multiset.map_congr rfl𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h:x.toCharges.Nodup⊢ ∀ x_1 ∈ x, (x_1.1, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = x_1.1) x)).sum) = id x_1
  intro p hp𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h:x.toCharges.Nodupp:𝓩 × Fluxeshp:p ∈ x⊢ (p.1, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = p.1) x)).sum) = id p
  simp only [id_eq]𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h:x.toCharges.Nodupp:𝓩 × Fluxeshp:p ∈ x⊢ (p.1, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = p.1) x)).sum) = p
  have x_noDup : x.Nodup := Multiset.Nodup.of_map Prod.fst h𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h:x.toCharges.Nodupp:𝓩 × Fluxeshp:p ∈ xx_noDup:Multiset.Nodup x⊢ (p.1, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = p.1) x)).sum) = p
  suffices (Multiset.filter (fun f => f.1 = p.1) x) = {p} by𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h:x.toCharges.Nodupp:𝓩 × Fluxeshp:p ∈ xx_noDup:Multiset.Nodup xthis:Multiset.filter (fun f => f.1 = p.1) x = {p}⊢ (p.1, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = p.1) x)).sum) = p𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h:x.toCharges.Nodupp:𝓩 × Fluxeshp:p ∈ xx_noDup:Multiset.Nodup x⊢ Multiset.filter (fun f => f.1 = p.1) x = {p} simp [this]𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h:x.toCharges.Nodupp:𝓩 × Fluxeshp:p ∈ xx_noDup:Multiset.Nodup x⊢ Multiset.filter (fun f => f.1 = p.1) x = {p}𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h:x.toCharges.Nodupp:𝓩 × Fluxeshp:p ∈ xx_noDup:Multiset.Nodup x⊢ Multiset.filter (fun f => f.1 = p.1) x = {p}
  refine (Multiset.Nodup.ext ?_ ?_).mpr ?_refine_1𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h:x.toCharges.Nodupp:𝓩 × Fluxeshp:p ∈ xx_noDup:Multiset.Nodup x⊢ (Multiset.filter (fun f => f.1 = p.1) x).Noduprefine_2𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h:x.toCharges.Nodupp:𝓩 × Fluxeshp:p ∈ xx_noDup:Multiset.Nodup x⊢ {p}.Noduprefine_3𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h:x.toCharges.Nodupp:𝓩 × Fluxeshp:p ∈ xx_noDup:Multiset.Nodup x⊢ ∀ (a : 𝓩 × Fluxes), a ∈ Multiset.filter (fun f => f.1 = p.1) x ↔ a ∈ {p}
  ·refine_1𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h:x.toCharges.Nodupp:𝓩 × Fluxeshp:p ∈ xx_noDup:Multiset.Nodup x⊢ (Multiset.filter (fun f => f.1 = p.1) x).Nodup exact Multiset.Nodup.filter (fun f => f.1 = p.1) x_noDupAll goals completed! 🐙
  ·refine_2𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h:x.toCharges.Nodupp:𝓩 × Fluxeshp:p ∈ xx_noDup:Multiset.Nodup x⊢ {p}.Nodup exact Multiset.nodup_singleton pAll goals completed! 🐙
  intro p'refine_3𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h:x.toCharges.Nodupp:𝓩 × Fluxeshp:p ∈ xx_noDup:Multiset.Nodup xp':𝓩 × Fluxes⊢ p' ∈ Multiset.filter (fun f => f.1 = p.1) x ↔ p' ∈ {p}
  simp only [Multiset.mem_filter, Multiset.mem_singleton]refine_3𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h:x.toCharges.Nodupp:𝓩 × Fluxeshp:p ∈ xx_noDup:Multiset.Nodup xp':𝓩 × Fluxes⊢ p' ∈ x ∧ p'.1 = p.1 ↔ p' = p
  constructorrefine_3.mp𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h:x.toCharges.Nodupp:𝓩 × Fluxeshp:p ∈ xx_noDup:Multiset.Nodup xp':𝓩 × Fluxes⊢ p' ∈ x ∧ p'.1 = p.1 → p' = prefine_3.mpr𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h:x.toCharges.Nodupp:𝓩 × Fluxeshp:p ∈ xx_noDup:Multiset.Nodup xp':𝓩 × Fluxes⊢ p' = p → p' ∈ x ∧ p'.1 = p.1
  ·refine_3.mp𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h:x.toCharges.Nodupp:𝓩 × Fluxeshp:p ∈ xx_noDup:Multiset.Nodup xp':𝓩 × Fluxes⊢ p' ∈ x ∧ p'.1 = p.1 → p' = p rintro ⟨h1, h2⟩refine_3.mp𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h:x.toCharges.Nodupp:𝓩 × Fluxeshp:p ∈ xx_noDup:Multiset.Nodup xp':𝓩 × Fluxesh1:p' ∈ xh2:p'.1 = p.1⊢ p' = p
    simp [toCharges] at hrefine_3.mp𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h:(Multiset.map Prod.fst x).Nodupp:𝓩 × Fluxeshp:p ∈ xx_noDup:Multiset.Nodup xp':𝓩 × Fluxesh1:p' ∈ xh2:p'.1 = p.1⊢ p' = p
    rw [Multiset.nodup_map_iff_inj_on x_noDuprefine_3.mp𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h:∀ x_1 ∈ x, ∀ y ∈ x, x_1.1 = y.1 → x_1 = yp:𝓩 × Fluxeshp:p ∈ xx_noDup:Multiset.Nodup xp':𝓩 × Fluxesh1:p' ∈ xh2:p'.1 = p.1⊢ p' = prefine_3.mp𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h:∀ x_1 ∈ x, ∀ y ∈ x, x_1.1 = y.1 → x_1 = yp:𝓩 × Fluxeshp:p ∈ xx_noDup:Multiset.Nodup xp':𝓩 × Fluxesh1:p' ∈ xh2:p'.1 = p.1⊢ p' = p] at hrefine_3.mp𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h:∀ x_1 ∈ x, ∀ y ∈ x, x_1.1 = y.1 → x_1 = yp:𝓩 × Fluxeshp:p ∈ xx_noDup:Multiset.Nodup xp':𝓩 × Fluxesh1:p' ∈ xh2:p'.1 = p.1⊢ p' = p
    exact h p' h1 p hp h2All goals completed! 🐙
  ·refine_3.mpr𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h:x.toCharges.Nodupp:𝓩 × Fluxeshp:p ∈ xx_noDup:Multiset.Nodup xp':𝓩 × Fluxes⊢ p' = p → p' ∈ x ∧ p'.1 = p.1 rintro ⟨rfl⟩refine_3.mpr𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h:x.toCharges.Nodupp:𝓩 × Fluxeshp:p ∈ xx_noDup:Multiset.Nodup x⊢ p ∈ x ∧ p.1 = p.1
    simp_allAll goals completed! 🐙

B.8. The charge map is preserved by reduction



lemma reduce_toChargeMap_eq (x : TenQuanta 𝓩) :
    x.reduce.toChargeMap = x.toChargeMap := by𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩⊢ x.reduce.toChargeMap = x.toChargeMap
  funext q𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩⊢ x.reduce.toChargeMap q = x.toChargeMap q
  by_cases h : q ∈ x.toChargespos𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∈ x.toCharges⊢ x.reduce.toChargeMap q = x.toChargeMap qneg𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∉ x.toCharges⊢ x.reduce.toChargeMap q = x.toChargeMap q
  ·pos𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∈ x.toCharges⊢ x.reduce.toChargeMap q = x.toChargeMap q rw [toChargeMap,pos𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∈ x.toCharges⊢ (Multiset.map Prod.snd (Multiset.filter (fun p => p.1 = q) x.reduce)).sum = x.toChargeMap qpos𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∈ x.toCharges⊢ (Multiset.map Prod.snd {(q, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q) x)).sum)}).sum =
  x.toChargeMap qpos.h𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∈ x.toCharges⊢ q ∈ x.toCharges reduce_filterpos𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∈ x.toCharges⊢ (Multiset.map Prod.snd {(q, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q) x)).sum)}).sum =
  x.toChargeMap qpos.h𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∈ x.toCharges⊢ q ∈ x.toChargespos𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∈ x.toCharges⊢ (Multiset.map Prod.snd {(q, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q) x)).sum)}).sum =
  x.toChargeMap qpos.h𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∈ x.toCharges⊢ q ∈ x.toCharges]pos𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∈ x.toCharges⊢ (Multiset.map Prod.snd {(q, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q) x)).sum)}).sum =
  x.toChargeMap qpos.h𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∈ x.toCharges⊢ q ∈ x.toCharges
    ·pos𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∈ x.toCharges⊢ (Multiset.map Prod.snd {(q, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q) x)).sum)}).sum =
  x.toChargeMap q simp [toChargeMap]All goals completed! 🐙
    ·pos.h𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∈ x.toCharges⊢ q ∈ x.toCharges exact hAll goals completed! 🐙
  ·neg𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∉ x.toCharges⊢ x.reduce.toChargeMap q = x.toChargeMap q rw [toChargeMap_of_not_mem,neg𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∉ x.toCharges⊢ 0 = x.toChargeMap qneg.h𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∉ x.toCharges⊢ q ∉ x.reduce.toChargesneg.h𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∉ x.toCharges⊢ q ∉ x.toChargesneg.h𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∉ x.toCharges⊢ q ∉ x.reduce.toCharges toChargeMap_of_not_memneg𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∉ x.toCharges⊢ 0 = 0neg.h𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∉ x.toCharges⊢ q ∉ x.toChargesneg.h𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∉ x.toCharges⊢ q ∉ x.reduce.toChargesneg.h𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∉ x.toCharges⊢ q ∉ x.toChargesneg.h𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∉ x.toCharges⊢ q ∉ x.reduce.toCharges]neg.h𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∉ x.toCharges⊢ q ∉ x.toChargesneg.h𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∉ x.toCharges⊢ q ∉ x.reduce.toCharges
    ·neg.h𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∉ x.toCharges⊢ q ∉ x.toCharges exact hAll goals completed! 🐙
    ·neg.h𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∉ x.toCharges⊢ q ∉ x.reduce.toCharges rw [reduce_toChargesneg.h𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∉ x.toCharges⊢ q ∉ x.toCharges.dedupneg.h𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∉ x.toCharges⊢ q ∉ x.toCharges.dedup]neg.h𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∉ x.toCharges⊢ q ∉ x.toCharges.dedup
      simp only [Multiset.mem_dedup]neg.h𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩h:q ∉ x.toCharges⊢ q ∉ x.toCharges
      exact hAll goals completed! 🐙

B.9. A fluxes in the reduced `TenQuanta` is a sum of fluxes in the original `TenQuanta`



lemma mem_powerset_sum_of_mem_reduce_toFluxesTen {F : TenQuanta 𝓩}
    {f : Fluxes} (hf : f ∈ F.reduce.toFluxesTen) :
    f ∈ (Multiset.powerset F.toFluxesTen).map fun s => s.sum := by𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩f:Fluxeshf:f ∈ F.reduce.toFluxesTen⊢ f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesTen)
  rw [toFluxesTen,𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩f:Fluxeshf:f ∈ Multiset.map Prod.snd F.reduce⊢ f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesTen)𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩f:Fluxeshf:∃ a ∈ F.reduce, a.2 = f⊢ f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesTen) Multiset.mem_map𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩f:Fluxeshf:∃ a ∈ F.reduce, a.2 = f⊢ f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesTen)𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩f:Fluxeshf:∃ a ∈ F.reduce, a.2 = f⊢ f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesTen)] at hf𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩f:Fluxeshf:∃ a ∈ F.reduce, a.2 = f⊢ f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesTen)
  obtain ⟨⟨q, f⟩, hp, rfl⟩ := hf𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩q:𝓩f:Fluxeshp:(q, f) ∈ F.reduce⊢ (q, f).2 ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesTen)
  rw [mem_reduce_iff𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩q:𝓩f:Fluxeshp:(q, f).1 ∈ F.toCharges ∧ (q, f).2 = (Multiset.map (fun y => y.2) (Multiset.filter (fun f_1 => f_1.1 = (q, f).1) F)).sum⊢ (q, f).2 ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesTen)𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩q:𝓩f:Fluxeshp:(q, f).1 ∈ F.toCharges ∧ (q, f).2 = (Multiset.map (fun y => y.2) (Multiset.filter (fun f_1 => f_1.1 = (q, f).1) F)).sum⊢ (q, f).2 ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesTen)] at hp𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩q:𝓩f:Fluxeshp:(q, f).1 ∈ F.toCharges ∧ (q, f).2 = (Multiset.map (fun y => y.2) (Multiset.filter (fun f_1 => f_1.1 = (q, f).1) F)).sum⊢ (q, f).2 ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesTen)
  simp at hp𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩q:𝓩f:Fluxeshp:q ∈ F.toCharges ∧ f = (Multiset.map (fun x => x.2) (Multiset.filter (fun x => x.1 = q) F)).sum⊢ (q, f).2 ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesTen)
  obtain ⟨hq, rfl⟩ := hp𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩q:𝓩hq:q ∈ F.toCharges⊢ (q, (Multiset.map (fun x => x.2) (Multiset.filter (fun x => x.1 = q) F)).sum).2 ∈
  Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesTen)
  simp only [Multiset.mem_map, Multiset.mem_powerset]𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩q:𝓩hq:q ∈ F.toCharges⊢ ∃ a ≤ F.toFluxesTen, a.sum = (Multiset.map (fun x => x.2) (Multiset.filter (fun x => x.1 = q) F)).sum
  use (Multiset.map (fun x => x.2) (Multiset.filter (fun x => x.1 = q) F))h𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩q:𝓩hq:q ∈ F.toCharges⊢ Multiset.map (fun x => x.2) (Multiset.filter (fun x => x.1 = q) F) ≤ F.toFluxesTen ∧
  (Multiset.map (fun x => x.2) (Multiset.filter (fun x => x.1 = q) F)).sum =
    (Multiset.map (fun x => x.2) (Multiset.filter (fun x => x.1 = q) F)).sum
  simp only [and_true]h𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩q:𝓩hq:q ∈ F.toCharges⊢ Multiset.map (fun x => x.2) (Multiset.filter (fun x => x.1 = q) F) ≤ F.toFluxesTen
  rw [toFluxesTenh𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩q:𝓩hq:q ∈ F.toCharges⊢ Multiset.map (fun x => x.2) (Multiset.filter (fun x => x.1 = q) F) ≤ Multiset.map Prod.snd Fh𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩q:𝓩hq:q ∈ F.toCharges⊢ Multiset.map (fun x => x.2) (Multiset.filter (fun x => x.1 = q) F) ≤ Multiset.map Prod.snd F]h𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩q:𝓩hq:q ∈ F.toCharges⊢ Multiset.map (fun x => x.2) (Multiset.filter (fun x => x.1 = q) F) ≤ Multiset.map Prod.snd F
  refine Multiset.map_le_map ?_h𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩q:𝓩hq:q ∈ F.toCharges⊢ Multiset.filter (fun x => x.1 = q) F ≤ F
  exact Multiset.filter_le (fun x => x.1 = q) FAll goals completed! 🐙



lemma mem_powerset_sum_of_mem_reduce_toFluxesTen_filter {F : TenQuanta 𝓩}
    {f : Fluxes} (hf : f ∈ F.reduce.toFluxesTen) :
    f ∈ (F.toFluxesTen.powerset.filter fun s => s ≠ 0).map fun s => s.sum := by𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩f:Fluxeshf:f ∈ F.reduce.toFluxesTen⊢ f ∈ Multiset.map (fun s => s.sum) (Multiset.filter (fun s => s ≠ 0) (Multiset.powerset F.toFluxesTen))
  rw [toFluxesTen,𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩f:Fluxeshf:f ∈ Multiset.map Prod.snd F.reduce⊢ f ∈ Multiset.map (fun s => s.sum) (Multiset.filter (fun s => s ≠ 0) (Multiset.powerset F.toFluxesTen))𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩f:Fluxeshf:∃ a ∈ F.reduce, a.2 = f⊢ f ∈ Multiset.map (fun s => s.sum) (Multiset.filter (fun s => s ≠ 0) (Multiset.powerset F.toFluxesTen)) Multiset.mem_map𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩f:Fluxeshf:∃ a ∈ F.reduce, a.2 = f⊢ f ∈ Multiset.map (fun s => s.sum) (Multiset.filter (fun s => s ≠ 0) (Multiset.powerset F.toFluxesTen))𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩f:Fluxeshf:∃ a ∈ F.reduce, a.2 = f⊢ f ∈ Multiset.map (fun s => s.sum) (Multiset.filter (fun s => s ≠ 0) (Multiset.powerset F.toFluxesTen))] at hf𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩f:Fluxeshf:∃ a ∈ F.reduce, a.2 = f⊢ f ∈ Multiset.map (fun s => s.sum) (Multiset.filter (fun s => s ≠ 0) (Multiset.powerset F.toFluxesTen))
  obtain ⟨⟨q, f⟩, hp, rfl⟩ := hf𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩q:𝓩f:Fluxeshp:(q, f) ∈ F.reduce⊢ (q, f).2 ∈ Multiset.map (fun s => s.sum) (Multiset.filter (fun s => s ≠ 0) (Multiset.powerset F.toFluxesTen))
  rw [mem_reduce_iff𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩q:𝓩f:Fluxeshp:(q, f).1 ∈ F.toCharges ∧ (q, f).2 = (Multiset.map (fun y => y.2) (Multiset.filter (fun f_1 => f_1.1 = (q, f).1) F)).sum⊢ (q, f).2 ∈ Multiset.map (fun s => s.sum) (Multiset.filter (fun s => s ≠ 0) (Multiset.powerset F.toFluxesTen))𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩q:𝓩f:Fluxeshp:(q, f).1 ∈ F.toCharges ∧ (q, f).2 = (Multiset.map (fun y => y.2) (Multiset.filter (fun f_1 => f_1.1 = (q, f).1) F)).sum⊢ (q, f).2 ∈ Multiset.map (fun s => s.sum) (Multiset.filter (fun s => s ≠ 0) (Multiset.powerset F.toFluxesTen))] at hp𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩q:𝓩f:Fluxeshp:(q, f).1 ∈ F.toCharges ∧ (q, f).2 = (Multiset.map (fun y => y.2) (Multiset.filter (fun f_1 => f_1.1 = (q, f).1) F)).sum⊢ (q, f).2 ∈ Multiset.map (fun s => s.sum) (Multiset.filter (fun s => s ≠ 0) (Multiset.powerset F.toFluxesTen))
  simp at hp𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩q:𝓩f:Fluxeshp:q ∈ F.toCharges ∧ f = (Multiset.map (fun x => x.2) (Multiset.filter (fun x => x.1 = q) F)).sum⊢ (q, f).2 ∈ Multiset.map (fun s => s.sum) (Multiset.filter (fun s => s ≠ 0) (Multiset.powerset F.toFluxesTen))
  obtain ⟨hq, rfl⟩ := hp𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩q:𝓩hq:q ∈ F.toCharges⊢ (q, (Multiset.map (fun x => x.2) (Multiset.filter (fun x => x.1 = q) F)).sum).2 ∈
  Multiset.map (fun s => s.sum) (Multiset.filter (fun s => s ≠ 0) (Multiset.powerset F.toFluxesTen))
  simp only [Multiset.mem_map]𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩q:𝓩hq:q ∈ F.toCharges⊢ ∃ a ∈ Multiset.filter (fun s => s ≠ 0) (Multiset.powerset F.toFluxesTen),
  a.sum = (Multiset.map (fun x => x.2) (Multiset.filter (fun x => x.1 = q) F)).sum
  use (Multiset.map (fun x => x.2) (Multiset.filter (fun x => x.1 = q) F))h𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩q:𝓩hq:q ∈ F.toCharges⊢ Multiset.map (fun x => x.2) (Multiset.filter (fun x => x.1 = q) F) ∈
    Multiset.filter (fun s => s ≠ 0) (Multiset.powerset F.toFluxesTen) ∧
  (Multiset.map (fun x => x.2) (Multiset.filter (fun x => x.1 = q) F)).sum =
    (Multiset.map (fun x => x.2) (Multiset.filter (fun x => x.1 = q) F)).sum
  simp only [ne_eq, Multiset.mem_filter, Multiset.mem_powerset, Multiset.map_eq_zero,
    Multiset.filter_eq_nil, Prod.forall, not_forall, Decidable.not_not, and_true]h𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩q:𝓩hq:q ∈ F.toCharges⊢ Multiset.map (fun x => x.2) (Multiset.filter (fun x => x.1 = q) F) ≤ F.toFluxesTen ∧
  ∃ x x_1, ∃ (_ : (x, x_1) ∈ F), x = q
  apply And.introh.left𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩q:𝓩hq:q ∈ F.toCharges⊢ Multiset.map (fun x => x.2) (Multiset.filter (fun x => x.1 = q) F) ≤ F.toFluxesTenh.right𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩q:𝓩hq:q ∈ F.toCharges⊢ ∃ x x_1, ∃ (_ : (x, x_1) ∈ F), x = q
  rw [toFluxesTenh.left𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩q:𝓩hq:q ∈ F.toCharges⊢ Multiset.map (fun x => x.2) (Multiset.filter (fun x => x.1 = q) F) ≤ Multiset.map Prod.snd Fh.right𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩q:𝓩hq:q ∈ F.toCharges⊢ ∃ x x_1, ∃ (_ : (x, x_1) ∈ F), x = qh.left𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩q:𝓩hq:q ∈ F.toCharges⊢ Multiset.map (fun x => x.2) (Multiset.filter (fun x => x.1 = q) F) ≤ Multiset.map Prod.snd Fh.right𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩q:𝓩hq:q ∈ F.toCharges⊢ ∃ x x_1, ∃ (_ : (x, x_1) ∈ F), x = q]h.left𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩q:𝓩hq:q ∈ F.toCharges⊢ Multiset.map (fun x => x.2) (Multiset.filter (fun x => x.1 = q) F) ≤ Multiset.map Prod.snd Fh.right𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩q:𝓩hq:q ∈ F.toCharges⊢ ∃ x x_1, ∃ (_ : (x, x_1) ∈ F), x = q
  refine Multiset.map_le_map ?_h.left𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩q:𝓩hq:q ∈ F.toCharges⊢ Multiset.filter (fun x => x.1 = q) F ≤ Fh.right𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩q:𝓩hq:q ∈ F.toCharges⊢ ∃ x x_1, ∃ (_ : (x, x_1) ∈ F), x = q
  exact Multiset.filter_le (fun x => x.1 = q) Fh.right𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩q:𝓩hq:q ∈ F.toCharges⊢ ∃ x x_1, ∃ (_ : (x, x_1) ∈ F), x = q
  simpa [toCharges] using hqAll goals completed! 🐙

B.10. No exotics condition on the reduced `TenQuanta`

B.10.1. Number of chiral `U`



lemma reduce_numChiralU_of_mem_elemsNoExotics {F : TenQuanta 𝓩}
    (hx : F.toFluxesTen ∈ FluxesTen.elemsNoExotics) :
    F.reduce.toFluxesTen.numChiralU = 3 := by𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ F.reduce.toFluxesTen.numChiralU = 3
  have hE : F.toFluxesTen.NoExotics := ((FluxesTen.noExotics_iff_mem_elemsNoExotics _).mpr hx).1𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExotics⊢ F.reduce.toFluxesTen.numChiralU = 3
  have numChiralU_eq_sum := F.toFluxesTen.numChiralU_eq_sum_sub_numAntiChiralU𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:F.toFluxesTen.numChiralU = F.toFluxesTen.chiralIndicesOfU.sum - F.toFluxesTen.numAntiChiralU⊢ F.reduce.toFluxesTen.numChiralU = 3
  rw [hE.2.2.1,𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = F.toFluxesTen.chiralIndicesOfU.sum - F.toFluxesTen.numAntiChiralU⊢ F.reduce.toFluxesTen.numChiralU = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralU = 3 hE.2.2.2.1,𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = F.toFluxesTen.chiralIndicesOfU.sum - 0⊢ F.reduce.toFluxesTen.numChiralU = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralU = 3 sub_zero,𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = F.toFluxesTen.chiralIndicesOfU.sum⊢ F.reduce.toFluxesTen.numChiralU = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralU = 3 FluxesTen.chiralIndicesOfU𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralU = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralU = 3] at numChiralU_eq_sum𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralU = 3
  have hmap : (F.reduce.toFluxesTen.map (fun f => f.M - f.N)).sum =
      (F.toFluxesTen.map (fun f => f.M - f.N)).sum := by
    have h := reduce_sum_eq_sum_toCharges F
      (fun _ => (⟨⟨fun f => f.M - f.N, by𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumx✝:𝓩⊢ Fluxes.M 0 - Fluxes.N 0 = 0𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumh:(Multiset.map
      (fun x =>
        match x with
        | (q, x) => { toFun := fun f => f.M - f.N, map_zero' := ⋯, map_add' := ⋯ } x)
      F.reduce).sum =
  (Multiset.map
      (fun x =>
        match x with
        | (q, x) => { toFun := fun f => f.M - f.N, map_zero' := ⋯, map_add' := ⋯ } x)
      F).sum⊢ (Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralU = 3 simpAll goals completed! 🐙𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumh:(Multiset.map
      (fun x =>
        match x with
        | (q, x) => { toFun := fun f => f.M - f.N, map_zero' := ⋯, map_add' := ⋯ } x)
      F.reduce).sum =
  (Multiset.map
      (fun x =>
        match x with
        | (q, x) => { toFun := fun f => f.M - f.N, map_zero' := ⋯, map_add' := ⋯ } x)
      F).sum⊢ (Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralU = 3⟩, fun a b => by𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumx✝:𝓩a:Fluxesb:Fluxes⊢ { toFun := fun f => f.M - f.N, map_zero' := ⋯ }.toFun (a + b) =
  { toFun := fun f => f.M - f.N, map_zero' := ⋯ }.toFun a + { toFun := fun f => f.M - f.N, map_zero' := ⋯ }.toFun b𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumh:(Multiset.map
      (fun x =>
        match x with
        | (q, x) => { toFun := fun f => f.M - f.N, map_zero' := ⋯, map_add' := ⋯ } x)
      F.reduce).sum =
  (Multiset.map
      (fun x =>
        match x with
        | (q, x) => { toFun := fun f => f.M - f.N, map_zero' := ⋯, map_add' := ⋯ } x)
      F).sum⊢ (Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralU = 3 simp𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumx✝:𝓩a:Fluxesb:Fluxes⊢ a.M + b.M - (a.N + b.N) = a.M - a.N + (b.M - b.N)𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumh:(Multiset.map
      (fun x =>
        match x with
        | (q, x) => { toFun := fun f => f.M - f.N, map_zero' := ⋯, map_add' := ⋯ } x)
      F.reduce).sum =
  (Multiset.map
      (fun x =>
        match x with
        | (q, x) => { toFun := fun f => f.M - f.N, map_zero' := ⋯, map_add' := ⋯ } x)
      F).sum⊢ (Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralU = 3; ringAll goals completed! 🐙𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumh:(Multiset.map
      (fun x =>
        match x with
        | (q, x) => { toFun := fun f => f.M - f.N, map_zero' := ⋯, map_add' := ⋯ } x)
      F.reduce).sum =
  (Multiset.map
      (fun x =>
        match x with
        | (q, x) => { toFun := fun f => f.M - f.N, map_zero' := ⋯, map_add' := ⋯ } x)
      F).sum⊢ (Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralU = 3⟩ : Fluxes →+ ℤ))𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumh:(Multiset.map
      (fun x =>
        match x with
        | (q, x) => { toFun := fun f => f.M - f.N, map_zero' := ⋯, map_add' := ⋯ } x)
      F.reduce).sum =
  (Multiset.map
      (fun x =>
        match x with
        | (q, x) => { toFun := fun f => f.M - f.N, map_zero' := ⋯, map_add' := ⋯ } x)
      F).sum⊢ (Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralU = 3
    simpa [toFluxesTen, Multiset.map_map, Function.comp] using h𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralU = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralU = 3
  rw [FluxesTen.numChiralU,𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum⊢ (Multiset.filter (fun x => 0 ≤ x) F.reduce.toFluxesTen.chiralIndicesOfU).sum = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum⊢ (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum⊢ ∀ a ∈ Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen, 0 ≤ a FluxesTen.chiralIndicesOfU,𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum⊢ (Multiset.filter (fun x => 0 ≤ x) (Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen)).sum = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum⊢ (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum⊢ ∀ a ∈ Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen, 0 ≤ a Multiset.filter_eq_self.mpr,𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum⊢ (Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen).sum = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum⊢ ∀ a ∈ Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen, 0 ≤ a𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum⊢ (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum⊢ ∀ a ∈ Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen, 0 ≤ a hmap𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum⊢ (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum⊢ ∀ a ∈ Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen, 0 ≤ a𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum⊢ (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum⊢ ∀ a ∈ Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen, 0 ≤ a]𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum⊢ (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum⊢ ∀ a ∈ Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen, 0 ≤ a
  ·𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum⊢ (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sum = 3 exact numChiralU_eq_sum.symmAll goals completed! 🐙
  intro a ha𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).suma:ℤha:a ∈ Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen⊢ 0 ≤ a
  obtain ⟨f, hf, rfl⟩ := Multiset.mem_map.mp ha𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumf:Fluxeshf:f ∈ F.reduce.toFluxesTenha:f.M - f.N ∈ Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen⊢ 0 ≤ f.M - f.N
  replace hf := mem_powerset_sum_of_mem_reduce_toFluxesTen hf𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralU_eq_sum:3 = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M - f.N) F.toFluxesTen).sumf:Fluxesha:f.M - f.N ∈ Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTenhf:f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesTen)⊢ 0 ≤ f.M - f.N
  clear ha hmap numChiralU_eq_sum hE𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticsf:Fluxeshf:f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesTen)⊢ 0 ≤ f.M - f.N
  generalize F.toFluxesTen = G at *𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩f:FluxesG:FluxesTenhx:G ∈ FluxesTen.elemsNoExoticshf:f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset G)⊢ 0 ≤ f.M - f.N
  revert f𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩G:FluxesTenhx:G ∈ FluxesTen.elemsNoExotics⊢ ∀ f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset G), 0 ≤ f.M - f.N
  revert G𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩⊢ ∀ G ∈ FluxesTen.elemsNoExotics, ∀ f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset G), 0 ≤ f.M - f.N
  decideAll goals completed! 🐙

B.10.2. Number of anti-chiral `U`



lemma reduce_numAntiChiralU_of_mem_elemsNoExotics {F : TenQuanta 𝓩}
    (hx : F.toFluxesTen ∈ FluxesTen.elemsNoExotics) :
    F.reduce.toFluxesTen.numAntiChiralU = 0 := by𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ F.reduce.toFluxesTen.numAntiChiralU = 0
  rw [FluxesTen.numAntiChiralU,𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ (Multiset.filter (fun x => x < 0) F.reduce.toFluxesTen.chiralIndicesOfU).sum = 0𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ ∀ a ∈ Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen, ¬a < 0 FluxesTen.chiralIndicesOfU,𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ (Multiset.filter (fun x => x < 0) (Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen)).sum = 0𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ ∀ a ∈ Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen, ¬a < 0 Multiset.filter_eq_nil.mpr,𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ Multiset.sum 0 = 0𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ ∀ a ∈ Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen, ¬a < 0𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ ∀ a ∈ Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen, ¬a < 0
    Multiset.sum_zero𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ 0 = 0𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ ∀ a ∈ Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen, ¬a < 0𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ ∀ a ∈ Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen, ¬a < 0]𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ ∀ a ∈ Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen, ¬a < 0
  intro a ha𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticsa:ℤha:a ∈ Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen⊢ ¬a < 0
  obtain ⟨f, hf, rfl⟩ := Multiset.mem_map.mp ha𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticsf:Fluxeshf:f ∈ F.reduce.toFluxesTenha:f.M - f.N ∈ Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTen⊢ ¬f.M - f.N < 0
  replace hf := mem_powerset_sum_of_mem_reduce_toFluxesTen hf𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticsf:Fluxesha:f.M - f.N ∈ Multiset.map (fun f => f.M - f.N) F.reduce.toFluxesTenhf:f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesTen)⊢ ¬f.M - f.N < 0
  clear ha𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticsf:Fluxeshf:f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesTen)⊢ ¬f.M - f.N < 0
  generalize F.toFluxesTen = G at *𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩f:FluxesG:FluxesTenhx:G ∈ FluxesTen.elemsNoExoticshf:f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset G)⊢ ¬f.M - f.N < 0
  revert f𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩G:FluxesTenhx:G ∈ FluxesTen.elemsNoExotics⊢ ∀ f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset G), ¬f.M - f.N < 0
  revert G𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩⊢ ∀ G ∈ FluxesTen.elemsNoExotics, ∀ f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset G), ¬f.M - f.N < 0
  decideAll goals completed! 🐙

B.10.3. Number of chiral `Q`



lemma reduce_numChiralQ_of_mem_elemsNoExotics {F : TenQuanta 𝓩}
    (hx : F.toFluxesTen ∈ FluxesTen.elemsNoExotics) :
    F.reduce.toFluxesTen.numChiralQ = 3 := by𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ F.reduce.toFluxesTen.numChiralQ = 3
  have hE : F.toFluxesTen.NoExotics := ((FluxesTen.noExotics_iff_mem_elemsNoExotics _).mpr hx).1𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExotics⊢ F.reduce.toFluxesTen.numChiralQ = 3
  have numChiralQ_eq_sum := F.toFluxesTen.numChiralQ_eq_sum_sub_numAntiChiralQ𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:F.toFluxesTen.numChiralQ = F.toFluxesTen.chiralIndicesOfQ.sum - F.toFluxesTen.numAntiChiralQ⊢ F.reduce.toFluxesTen.numChiralQ = 3
  rw [hE.1,𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = F.toFluxesTen.chiralIndicesOfQ.sum - F.toFluxesTen.numAntiChiralQ⊢ F.reduce.toFluxesTen.numChiralQ = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralQ = 3 hE.2.1,𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = F.toFluxesTen.chiralIndicesOfQ.sum - 0⊢ F.reduce.toFluxesTen.numChiralQ = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralQ = 3 sub_zero,𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = F.toFluxesTen.chiralIndicesOfQ.sum⊢ F.reduce.toFluxesTen.numChiralQ = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralQ = 3 FluxesTen.chiralIndicesOfQ𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralQ = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralQ = 3] at numChiralQ_eq_sum𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralQ = 3
  have hmap : (F.reduce.toFluxesTen.map (fun f => f.M)).sum =
      (F.toFluxesTen.map (fun f => f.M)).sum := by
    have h := reduce_sum_eq_sum_toCharges F
      (fun _ => (⟨⟨fun f => f.M, by𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sumx✝:𝓩⊢ Fluxes.M 0 = 0𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sumh:(Multiset.map
      (fun x =>
        match x with
        | (q, x) => { toFun := fun f => f.M, map_zero' := ⋯, map_add' := ⋯ } x)
      F.reduce).sum =
  (Multiset.map
      (fun x =>
        match x with
        | (q, x) => { toFun := fun f => f.M, map_zero' := ⋯, map_add' := ⋯ } x)
      F).sum⊢ (Multiset.map (fun f => f.M) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M) F.toFluxesTen).sum𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralQ = 3 simpAll goals completed! 🐙𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sumh:(Multiset.map
      (fun x =>
        match x with
        | (q, x) => { toFun := fun f => f.M, map_zero' := ⋯, map_add' := ⋯ } x)
      F.reduce).sum =
  (Multiset.map
      (fun x =>
        match x with
        | (q, x) => { toFun := fun f => f.M, map_zero' := ⋯, map_add' := ⋯ } x)
      F).sum⊢ (Multiset.map (fun f => f.M) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M) F.toFluxesTen).sum𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralQ = 3⟩, fun a b => by𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sumx✝:𝓩a:Fluxesb:Fluxes⊢ { toFun := fun f => f.M, map_zero' := ⋯ }.toFun (a + b) =
  { toFun := fun f => f.M, map_zero' := ⋯ }.toFun a + { toFun := fun f => f.M, map_zero' := ⋯ }.toFun b𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sumh:(Multiset.map
      (fun x =>
        match x with
        | (q, x) => { toFun := fun f => f.M, map_zero' := ⋯, map_add' := ⋯ } x)
      F.reduce).sum =
  (Multiset.map
      (fun x =>
        match x with
        | (q, x) => { toFun := fun f => f.M, map_zero' := ⋯, map_add' := ⋯ } x)
      F).sum⊢ (Multiset.map (fun f => f.M) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M) F.toFluxesTen).sum𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralQ = 3 simpAll goals completed! 🐙𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sumh:(Multiset.map
      (fun x =>
        match x with
        | (q, x) => { toFun := fun f => f.M, map_zero' := ⋯, map_add' := ⋯ } x)
      F.reduce).sum =
  (Multiset.map
      (fun x =>
        match x with
        | (q, x) => { toFun := fun f => f.M, map_zero' := ⋯, map_add' := ⋯ } x)
      F).sum⊢ (Multiset.map (fun f => f.M) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M) F.toFluxesTen).sum𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralQ = 3⟩ : Fluxes →+ ℤ))𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sumh:(Multiset.map
      (fun x =>
        match x with
        | (q, x) => { toFun := fun f => f.M, map_zero' := ⋯, map_add' := ⋯ } x)
      F.reduce).sum =
  (Multiset.map
      (fun x =>
        match x with
        | (q, x) => { toFun := fun f => f.M, map_zero' := ⋯, map_add' := ⋯ } x)
      F).sum⊢ (Multiset.map (fun f => f.M) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M) F.toFluxesTen).sum𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralQ = 3
    simpa [toFluxesTen, Multiset.map_map, Function.comp] using h𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralQ = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralQ = 3
  rw [FluxesTen.numChiralQ,𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M) F.toFluxesTen).sum⊢ (Multiset.filter (fun x => 0 ≤ x) F.reduce.toFluxesTen.chiralIndicesOfQ).sum = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M) F.toFluxesTen).sum⊢ (Multiset.map (fun f => f.M) F.toFluxesTen).sum = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M) F.toFluxesTen).sum⊢ ∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesTen, 0 ≤ a FluxesTen.chiralIndicesOfQ,𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M) F.toFluxesTen).sum⊢ (Multiset.filter (fun x => 0 ≤ x) (Multiset.map (fun f => f.M) F.reduce.toFluxesTen)).sum = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M) F.toFluxesTen).sum⊢ (Multiset.map (fun f => f.M) F.toFluxesTen).sum = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M) F.toFluxesTen).sum⊢ ∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesTen, 0 ≤ a Multiset.filter_eq_self.mpr,𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M) F.toFluxesTen).sum⊢ (Multiset.map (fun f => f.M) F.reduce.toFluxesTen).sum = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M) F.toFluxesTen).sum⊢ ∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesTen, 0 ≤ a𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M) F.toFluxesTen).sum⊢ (Multiset.map (fun f => f.M) F.toFluxesTen).sum = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M) F.toFluxesTen).sum⊢ ∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesTen, 0 ≤ a hmap𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M) F.toFluxesTen).sum⊢ (Multiset.map (fun f => f.M) F.toFluxesTen).sum = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M) F.toFluxesTen).sum⊢ ∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesTen, 0 ≤ a𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M) F.toFluxesTen).sum⊢ (Multiset.map (fun f => f.M) F.toFluxesTen).sum = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M) F.toFluxesTen).sum⊢ ∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesTen, 0 ≤ a]𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M) F.toFluxesTen).sum⊢ (Multiset.map (fun f => f.M) F.toFluxesTen).sum = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M) F.toFluxesTen).sum⊢ ∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesTen, 0 ≤ a
  ·𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M) F.toFluxesTen).sum⊢ (Multiset.map (fun f => f.M) F.toFluxesTen).sum = 3 exact numChiralQ_eq_sum.symmAll goals completed! 🐙
  intro a ha𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M) F.toFluxesTen).suma:ℤha:a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesTen⊢ 0 ≤ a
  obtain ⟨f, hf, rfl⟩ := Multiset.mem_map.mp ha𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M) F.toFluxesTen).sumf:Fluxeshf:f ∈ F.reduce.toFluxesTenha:f.M ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesTen⊢ 0 ≤ f.M
  replace hf := mem_powerset_sum_of_mem_reduce_toFluxesTen hf𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralQ_eq_sum:3 = (Multiset.map (fun f => f.M) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M) F.toFluxesTen).sumf:Fluxesha:f.M ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesTenhf:f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesTen)⊢ 0 ≤ f.M
  clear ha hmap numChiralQ_eq_sum hE𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticsf:Fluxeshf:f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesTen)⊢ 0 ≤ f.M
  generalize F.toFluxesTen = G at *𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩f:FluxesG:FluxesTenhx:G ∈ FluxesTen.elemsNoExoticshf:f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset G)⊢ 0 ≤ f.M
  revert f𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩G:FluxesTenhx:G ∈ FluxesTen.elemsNoExotics⊢ ∀ f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset G), 0 ≤ f.M
  revert G𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩⊢ ∀ G ∈ FluxesTen.elemsNoExotics, ∀ f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset G), 0 ≤ f.M
  decideAll goals completed! 🐙

B.10.4. Number of anti-chiral `Q`



lemma reduce_numAntiChiralQ_of_mem_elemsNoExotics {F : TenQuanta 𝓩}
    (hx : F.toFluxesTen ∈ FluxesTen.elemsNoExotics) :
    F.reduce.toFluxesTen.numAntiChiralQ = 0 := by𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ F.reduce.toFluxesTen.numAntiChiralQ = 0
  rw [FluxesTen.numAntiChiralQ,𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ (Multiset.filter (fun x => x < 0) F.reduce.toFluxesTen.chiralIndicesOfQ).sum = 0𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ ∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesTen, ¬a < 0 FluxesTen.chiralIndicesOfQ,𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ (Multiset.filter (fun x => x < 0) (Multiset.map (fun f => f.M) F.reduce.toFluxesTen)).sum = 0𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ ∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesTen, ¬a < 0 Multiset.filter_eq_nil.mpr,𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ Multiset.sum 0 = 0𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ ∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesTen, ¬a < 0𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ ∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesTen, ¬a < 0
    Multiset.sum_zero𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ 0 = 0𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ ∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesTen, ¬a < 0𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ ∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesTen, ¬a < 0]𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ ∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesTen, ¬a < 0
  intro a ha𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticsa:ℤha:a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesTen⊢ ¬a < 0
  obtain ⟨f, hf, rfl⟩ := Multiset.mem_map.mp ha𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticsf:Fluxeshf:f ∈ F.reduce.toFluxesTenha:f.M ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesTen⊢ ¬f.M < 0
  replace hf := mem_powerset_sum_of_mem_reduce_toFluxesTen hf𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticsf:Fluxesha:f.M ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesTenhf:f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesTen)⊢ ¬f.M < 0
  clear ha𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticsf:Fluxeshf:f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesTen)⊢ ¬f.M < 0
  generalize F.toFluxesTen = G at *𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩f:FluxesG:FluxesTenhx:G ∈ FluxesTen.elemsNoExoticshf:f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset G)⊢ ¬f.M < 0
  revert f𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩G:FluxesTenhx:G ∈ FluxesTen.elemsNoExotics⊢ ∀ f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset G), ¬f.M < 0
  revert G𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩⊢ ∀ G ∈ FluxesTen.elemsNoExotics, ∀ f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset G), ¬f.M < 0
  decideAll goals completed! 🐙

B.10.5. Number of chiral `E`



lemma reduce_numChiralE_of_mem_elemsNoExotics {F : TenQuanta 𝓩}
    (hx : F.toFluxesTen ∈ FluxesTen.elemsNoExotics) :
    F.reduce.toFluxesTen.numChiralE = 3 := by𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ F.reduce.toFluxesTen.numChiralE = 3
  have hE : F.toFluxesTen.NoExotics := ((FluxesTen.noExotics_iff_mem_elemsNoExotics _).mpr hx).1𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExotics⊢ F.reduce.toFluxesTen.numChiralE = 3
  have numChiralE_eq_sum := F.toFluxesTen.numChiralE_eq_sum_sub_numAntiChiralE𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:F.toFluxesTen.numChiralE = F.toFluxesTen.chiralIndicesOfE.sum - F.toFluxesTen.numAntiChiralE⊢ F.reduce.toFluxesTen.numChiralE = 3
  rw [hE.2.2.2.2.1,𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = F.toFluxesTen.chiralIndicesOfE.sum - F.toFluxesTen.numAntiChiralE⊢ F.reduce.toFluxesTen.numChiralE = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralE = 3 hE.2.2.2.2.2,𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = F.toFluxesTen.chiralIndicesOfE.sum - 0⊢ F.reduce.toFluxesTen.numChiralE = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralE = 3 sub_zero,𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = F.toFluxesTen.chiralIndicesOfE.sum⊢ F.reduce.toFluxesTen.numChiralE = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralE = 3 FluxesTen.chiralIndicesOfE𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralE = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralE = 3] at numChiralE_eq_sum𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralE = 3
  have hmap : (F.reduce.toFluxesTen.map (fun f => f.M + f.N)).sum =
      (F.toFluxesTen.map (fun f => f.M + f.N)).sum := by
    have h := reduce_sum_eq_sum_toCharges F
      (fun _ => (⟨⟨fun f => f.M + f.N, by𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumx✝:𝓩⊢ Fluxes.M 0 + Fluxes.N 0 = 0𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumh:(Multiset.map
      (fun x =>
        match x with
        | (q, x) => { toFun := fun f => f.M + f.N, map_zero' := ⋯, map_add' := ⋯ } x)
      F.reduce).sum =
  (Multiset.map
      (fun x =>
        match x with
        | (q, x) => { toFun := fun f => f.M + f.N, map_zero' := ⋯, map_add' := ⋯ } x)
      F).sum⊢ (Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralE = 3 simpAll goals completed! 🐙𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumh:(Multiset.map
      (fun x =>
        match x with
        | (q, x) => { toFun := fun f => f.M + f.N, map_zero' := ⋯, map_add' := ⋯ } x)
      F.reduce).sum =
  (Multiset.map
      (fun x =>
        match x with
        | (q, x) => { toFun := fun f => f.M + f.N, map_zero' := ⋯, map_add' := ⋯ } x)
      F).sum⊢ (Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralE = 3⟩, fun a b => by𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumx✝:𝓩a:Fluxesb:Fluxes⊢ { toFun := fun f => f.M + f.N, map_zero' := ⋯ }.toFun (a + b) =
  { toFun := fun f => f.M + f.N, map_zero' := ⋯ }.toFun a + { toFun := fun f => f.M + f.N, map_zero' := ⋯ }.toFun b𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumh:(Multiset.map
      (fun x =>
        match x with
        | (q, x) => { toFun := fun f => f.M + f.N, map_zero' := ⋯, map_add' := ⋯ } x)
      F.reduce).sum =
  (Multiset.map
      (fun x =>
        match x with
        | (q, x) => { toFun := fun f => f.M + f.N, map_zero' := ⋯, map_add' := ⋯ } x)
      F).sum⊢ (Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralE = 3 simp𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumx✝:𝓩a:Fluxesb:Fluxes⊢ a.M + b.M + (a.N + b.N) = a.M + a.N + (b.M + b.N)𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumh:(Multiset.map
      (fun x =>
        match x with
        | (q, x) => { toFun := fun f => f.M + f.N, map_zero' := ⋯, map_add' := ⋯ } x)
      F.reduce).sum =
  (Multiset.map
      (fun x =>
        match x with
        | (q, x) => { toFun := fun f => f.M + f.N, map_zero' := ⋯, map_add' := ⋯ } x)
      F).sum⊢ (Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralE = 3; ringAll goals completed! 🐙𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumh:(Multiset.map
      (fun x =>
        match x with
        | (q, x) => { toFun := fun f => f.M + f.N, map_zero' := ⋯, map_add' := ⋯ } x)
      F.reduce).sum =
  (Multiset.map
      (fun x =>
        match x with
        | (q, x) => { toFun := fun f => f.M + f.N, map_zero' := ⋯, map_add' := ⋯ } x)
      F).sum⊢ (Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralE = 3⟩ : Fluxes →+ ℤ))𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumh:(Multiset.map
      (fun x =>
        match x with
        | (q, x) => { toFun := fun f => f.M + f.N, map_zero' := ⋯, map_add' := ⋯ } x)
      F.reduce).sum =
  (Multiset.map
      (fun x =>
        match x with
        | (q, x) => { toFun := fun f => f.M + f.N, map_zero' := ⋯, map_add' := ⋯ } x)
      F).sum⊢ (Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralE = 3
    simpa [toFluxesTen, Multiset.map_map, Function.comp] using h𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralE = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum⊢ F.reduce.toFluxesTen.numChiralE = 3
  rw [FluxesTen.numChiralE,𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum⊢ (Multiset.filter (fun x => 0 ≤ x) F.reduce.toFluxesTen.chiralIndicesOfE).sum = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum⊢ (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum⊢ ∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen, 0 ≤ a FluxesTen.chiralIndicesOfE,𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum⊢ (Multiset.filter (fun x => 0 ≤ x) (Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen)).sum = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum⊢ (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum⊢ ∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen, 0 ≤ a Multiset.filter_eq_self.mpr,𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum⊢ (Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen).sum = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum⊢ ∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen, 0 ≤ a𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum⊢ (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum⊢ ∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen, 0 ≤ a hmap𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum⊢ (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum⊢ ∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen, 0 ≤ a𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum⊢ (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum⊢ ∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen, 0 ≤ a]𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum⊢ (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum = 3𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum⊢ ∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen, 0 ≤ a
  ·𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum⊢ (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sum = 3 exact numChiralE_eq_sum.symmAll goals completed! 🐙
  intro a ha𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).suma:ℤha:a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen⊢ 0 ≤ a
  obtain ⟨f, hf, rfl⟩ := Multiset.mem_map.mp ha𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumf:Fluxeshf:f ∈ F.reduce.toFluxesTenha:f.M + f.N ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen⊢ 0 ≤ f.M + f.N
  replace hf := mem_powerset_sum_of_mem_reduce_toFluxesTen hf𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticshE:F.toFluxesTen.NoExoticsnumChiralE_eq_sum:3 = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumhmap:(Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen).sum = (Multiset.map (fun f => f.M + f.N) F.toFluxesTen).sumf:Fluxesha:f.M + f.N ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTenhf:f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesTen)⊢ 0 ≤ f.M + f.N
  clear ha hmap numChiralE_eq_sum hE𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticsf:Fluxeshf:f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesTen)⊢ 0 ≤ f.M + f.N
  generalize F.toFluxesTen = G at *𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩f:FluxesG:FluxesTenhx:G ∈ FluxesTen.elemsNoExoticshf:f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset G)⊢ 0 ≤ f.M + f.N
  revert f𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩G:FluxesTenhx:G ∈ FluxesTen.elemsNoExotics⊢ ∀ f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset G), 0 ≤ f.M + f.N
  revert G𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩⊢ ∀ G ∈ FluxesTen.elemsNoExotics, ∀ f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset G), 0 ≤ f.M + f.N
  decideAll goals completed! 🐙

B.10.6. Number of anti-chiral `E`



lemma reduce_numAntiChiralE_of_mem_elemsNoExotics {F : TenQuanta 𝓩}
    (hx : F.toFluxesTen ∈ FluxesTen.elemsNoExotics) :
    F.reduce.toFluxesTen.numAntiChiralE = 0 := by𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ F.reduce.toFluxesTen.numAntiChiralE = 0
  rw [FluxesTen.numAntiChiralE,𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ (Multiset.filter (fun x => x < 0) F.reduce.toFluxesTen.chiralIndicesOfE).sum = 0𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ ∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen, ¬a < 0 FluxesTen.chiralIndicesOfE,𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ (Multiset.filter (fun x => x < 0) (Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen)).sum = 0𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ ∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen, ¬a < 0 Multiset.filter_eq_nil.mpr,𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ Multiset.sum 0 = 0𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ ∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen, ¬a < 0𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ ∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen, ¬a < 0
    Multiset.sum_zero𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ 0 = 0𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ ∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen, ¬a < 0𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ ∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen, ¬a < 0]𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ ∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen, ¬a < 0
  intro a ha𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticsa:ℤha:a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen⊢ ¬a < 0
  obtain ⟨f, hf, rfl⟩ := Multiset.mem_map.mp ha𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticsf:Fluxeshf:f ∈ F.reduce.toFluxesTenha:f.M + f.N ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTen⊢ ¬f.M + f.N < 0
  replace hf := mem_powerset_sum_of_mem_reduce_toFluxesTen hf𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticsf:Fluxesha:f.M + f.N ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesTenhf:f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesTen)⊢ ¬f.M + f.N < 0
  clear ha𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticsf:Fluxeshf:f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesTen)⊢ ¬f.M + f.N < 0
  generalize F.toFluxesTen = G at *𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩f:FluxesG:FluxesTenhx:G ∈ FluxesTen.elemsNoExoticshf:f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset G)⊢ ¬f.M + f.N < 0
  revert f𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩G:FluxesTenhx:G ∈ FluxesTen.elemsNoExotics⊢ ∀ f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset G), ¬f.M + f.N < 0
  revert G𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩⊢ ∀ G ∈ FluxesTen.elemsNoExotics, ∀ f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset G), ¬f.M + f.N < 0
  decideAll goals completed! 🐙

B.10.7. The `NoExotics` condition on the reduced `TenQuanta`



lemma reduce_noExotics_of_mem_elemsNoExotics {F : TenQuanta 𝓩}
    (hx : F.toFluxesTen ∈ FluxesTen.elemsNoExotics) :
    F.reduce.toFluxesTen.NoExotics := by𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ F.reduce.toFluxesTen.NoExotics
  rw [FluxesTen.NoExotics,𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ F.reduce.toFluxesTen.numChiralQ = 3 ∧
  F.reduce.toFluxesTen.numAntiChiralQ = 0 ∧
    F.reduce.toFluxesTen.numChiralU = 3 ∧
      F.reduce.toFluxesTen.numAntiChiralU = 0 ∧
        F.reduce.toFluxesTen.numChiralE = 3 ∧ F.reduce.toFluxesTen.numAntiChiralE = 0𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ 3 = 3 ∧ 0 = 0 ∧ 3 = 3 ∧ 0 = 0 ∧ 3 = 3 ∧ 0 = 0 reduce_numChiralU_of_mem_elemsNoExotics hx,𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ F.reduce.toFluxesTen.numChiralQ = 3 ∧
  F.reduce.toFluxesTen.numAntiChiralQ = 0 ∧
    3 = 3 ∧
      F.reduce.toFluxesTen.numAntiChiralU = 0 ∧
        F.reduce.toFluxesTen.numChiralE = 3 ∧ F.reduce.toFluxesTen.numAntiChiralE = 0𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ 3 = 3 ∧ 0 = 0 ∧ 3 = 3 ∧ 0 = 0 ∧ 3 = 3 ∧ 0 = 0
    reduce_numAntiChiralU_of_mem_elemsNoExotics hx,𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ F.reduce.toFluxesTen.numChiralQ = 3 ∧
  F.reduce.toFluxesTen.numAntiChiralQ = 0 ∧
    3 = 3 ∧ 0 = 0 ∧ F.reduce.toFluxesTen.numChiralE = 3 ∧ F.reduce.toFluxesTen.numAntiChiralE = 0𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ 3 = 3 ∧ 0 = 0 ∧ 3 = 3 ∧ 0 = 0 ∧ 3 = 3 ∧ 0 = 0 reduce_numChiralQ_of_mem_elemsNoExotics hx,𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ 3 = 3 ∧
  F.reduce.toFluxesTen.numAntiChiralQ = 0 ∧
    3 = 3 ∧ 0 = 0 ∧ F.reduce.toFluxesTen.numChiralE = 3 ∧ F.reduce.toFluxesTen.numAntiChiralE = 0𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ 3 = 3 ∧ 0 = 0 ∧ 3 = 3 ∧ 0 = 0 ∧ 3 = 3 ∧ 0 = 0
    reduce_numAntiChiralQ_of_mem_elemsNoExotics hx,𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ 3 = 3 ∧ 0 = 0 ∧ 3 = 3 ∧ 0 = 0 ∧ F.reduce.toFluxesTen.numChiralE = 3 ∧ F.reduce.toFluxesTen.numAntiChiralE = 0𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ 3 = 3 ∧ 0 = 0 ∧ 3 = 3 ∧ 0 = 0 ∧ 3 = 3 ∧ 0 = 0 reduce_numChiralE_of_mem_elemsNoExotics hx,𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ 3 = 3 ∧ 0 = 0 ∧ 3 = 3 ∧ 0 = 0 ∧ 3 = 3 ∧ F.reduce.toFluxesTen.numAntiChiralE = 0𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ 3 = 3 ∧ 0 = 0 ∧ 3 = 3 ∧ 0 = 0 ∧ 3 = 3 ∧ 0 = 0
    reduce_numAntiChiralE_of_mem_elemsNoExotics hx𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ 3 = 3 ∧ 0 = 0 ∧ 3 = 3 ∧ 0 = 0 ∧ 3 = 3 ∧ 0 = 0𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ 3 = 3 ∧ 0 = 0 ∧ 3 = 3 ∧ 0 = 0 ∧ 3 = 3 ∧ 0 = 0]𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ 3 = 3 ∧ 0 = 0 ∧ 3 = 3 ∧ 0 = 0 ∧ 3 = 3 ∧ 0 = 0
  simpAll goals completed! 🐙

B.11. Reduce member of `FLuxesTen.elemsNoExotics`



lemma reduce_mem_elemsNoExotics {F : TenQuanta 𝓩}
    (hx : F.toFluxesTen ∈ FluxesTen.elemsNoExotics) :
    F.reduce.toFluxesTen ∈ FluxesTen.elemsNoExotics := by𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ F.reduce.toFluxesTen ∈ FluxesTen.elemsNoExotics
  rw [← FluxesTen.noExotics_iff_mem_elemsNoExotics𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ F.reduce.toFluxesTen.NoExotics ∧ F.reduce.toFluxesTen.HasNoZero𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ F.reduce.toFluxesTen.NoExotics ∧ F.reduce.toFluxesTen.HasNoZero]𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ F.reduce.toFluxesTen.NoExotics ∧ F.reduce.toFluxesTen.HasNoZero
  refine ⟨reduce_noExotics_of_mem_elemsNoExotics hx, ?_⟩𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ F.reduce.toFluxesTen.HasNoZero
  intro h𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticsh:0 ∈ F.reduce.toFluxesTen⊢ False
  replace h := mem_powerset_sum_of_mem_reduce_toFluxesTen_filter h𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩hx:F.toFluxesTen ∈ FluxesTen.elemsNoExoticsh:0 ∈ Multiset.map (fun s => s.sum) (Multiset.filter (fun s => s ≠ 0) (Multiset.powerset F.toFluxesTen))⊢ False
  generalize F.toFluxesTen = G at *𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩G:FluxesTenhx:G ∈ FluxesTen.elemsNoExoticsh:0 ∈ Multiset.map (fun s => s.sum) (Multiset.filter (fun s => s ≠ 0) (Multiset.powerset G))⊢ False
  revert G𝓩:Typeinst✝:DecidableEq 𝓩F:TenQuanta 𝓩⊢ ∀ G ∈ FluxesTen.elemsNoExotics,
  0 ∈ Multiset.map (fun s => s.sum) (Multiset.filter (fun s => s ≠ 0) (Multiset.powerset G)) → False
  decideAll goals completed! 🐙

C. Decomposition of a `TenQuanta` into basic fluxes

C.1. Decomposition of fluxes

The decomposition of a relevant flux into ⟨1, 0⟩, ⟨1, 1⟩ and ⟨1, -1⟩ .

def decomposeFluxes (f : Fluxes) : Multiset Fluxes :=
  if f = ⟨1, 0⟩ then {⟨1, 0⟩}
  else if f = ⟨1, 1⟩ then {⟨1, 1⟩}
  else if f = ⟨1, -1⟩ then {⟨1, -1⟩}
  else if f = ⟨2, 1⟩ then {⟨1, 1⟩, ⟨1, 0⟩}
  else if f = ⟨2, -1⟩ then {⟨1, -1⟩, ⟨1, 0⟩}
  else if f = ⟨3, 0⟩ then {⟨1, 0⟩, ⟨1, 0⟩, ⟨1, 0⟩}
  else if f = ⟨2, 0⟩ then {⟨1, 0⟩, ⟨1, 0⟩}
  else {f}

lemma decomposeFluxes_sum_of_noExotics (f : Fluxes) (hf : ∃ F ∈ FluxesTen.elemsNoExotics, f ∈ F) :
    (decomposeFluxes f).sum = f := byf:Fluxeshf:∃ F ∈ FluxesTen.elemsNoExotics, f ∈ F⊢ (decomposeFluxes f).sum = f
  obtain ⟨F, hF, hfF⟩ := hff:FluxesF:FluxesTenhF:F ∈ FluxesTen.elemsNoExoticshfF:f ∈ F⊢ (decomposeFluxes f).sum = f
  revert fF:FluxesTenhF:F ∈ FluxesTen.elemsNoExotics⊢ ∀ f ∈ F, (decomposeFluxes f).sum = f
  revert F⊢ ∀ F ∈ FluxesTen.elemsNoExotics, ∀ f ∈ F, (decomposeFluxes f).sum = f
  decideAll goals completed! 🐙

C.2. Decomposition of a `TenQuanta` (with no exotics)

The decomposition of a TenQuanta into a TenQuanta which has the same reduce by has fluxes {⟨1, 0⟩, ⟨1, 0⟩, ⟨1, 0⟩} or {⟨1, 1⟩, ⟨1, -1⟩, ⟨1, 0⟩} only.

This only works for fluxes which have no exotics or zeros.

def decompose (x : TenQuanta 𝓩) : TenQuanta 𝓩 :=
  x.bind fun p => (decomposeFluxes p.2).map fun f => (p.1, f)

C.2.1. Decomposition distributes over addition

lemma decompose_add (x y : TenQuanta 𝓩) :
    (x + y).decompose = x.decompose + y.decompose := by𝓩:Typex:TenQuanta 𝓩y:TenQuanta 𝓩⊢ (x + y).decompose = x.decompose + y.decompose
  simp [decompose]All goals completed! 🐙

C.2.2. Decomposition commutes with filtering charges



lemma decompose_filter_charge [DecidableEq 𝓩] (x : TenQuanta 𝓩) (q : 𝓩) :
    (x.decompose).filter (fun p => p.1 = q) =
    decompose (x.filter (fun p => p.1 = q)) := by𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩⊢ Multiset.filter (fun p => p.1 = q) x.decompose = decompose (Multiset.filter (fun p => p.1 = q) x)
  rw [decompose𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩⊢ Multiset.filter (fun p => p.1 = q) (Multiset.bind x fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
  decompose (Multiset.filter (fun p => p.1 = q) x)𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩⊢ Multiset.filter (fun p => p.1 = q) (Multiset.bind x fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
  decompose (Multiset.filter (fun p => p.1 = q) x)]𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩⊢ Multiset.filter (fun p => p.1 = q) (Multiset.bind x fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
  decompose (Multiset.filter (fun p => p.1 = q) x)
  revert x𝓩:Typeinst✝:DecidableEq 𝓩q:𝓩⊢ ∀ (x : TenQuanta 𝓩),
  Multiset.filter (fun p => p.1 = q) (Multiset.bind x fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
    decompose (Multiset.filter (fun p => p.1 = q) x)
  apply Multiset.inductionempty𝓩:Typeinst✝:DecidableEq 𝓩q:𝓩⊢ Multiset.filter (fun p => p.1 = q) (Multiset.bind 0 fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
  decompose (Multiset.filter (fun p => p.1 = q) 0)cons𝓩:Typeinst✝:DecidableEq 𝓩q:𝓩⊢ ∀ (a : 𝓩 × Fluxes) (s : Multiset (𝓩 × Fluxes)),
  Multiset.filter (fun p => p.1 = q) (s.bind fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
      decompose (Multiset.filter (fun p => p.1 = q) s) →
    Multiset.filter (fun p => p.1 = q)
        ((a ::ₘ s).bind fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
      decompose (Multiset.filter (fun p => p.1 = q) (a ::ₘ s))
  ·empty𝓩:Typeinst✝:DecidableEq 𝓩q:𝓩⊢ Multiset.filter (fun p => p.1 = q) (Multiset.bind 0 fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
  decompose (Multiset.filter (fun p => p.1 = q) 0) simp [decompose]All goals completed! 🐙
  ·cons𝓩:Typeinst✝:DecidableEq 𝓩q:𝓩⊢ ∀ (a : 𝓩 × Fluxes) (s : Multiset (𝓩 × Fluxes)),
  Multiset.filter (fun p => p.1 = q) (s.bind fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
      decompose (Multiset.filter (fun p => p.1 = q) s) →
    Multiset.filter (fun p => p.1 = q)
        ((a ::ₘ s).bind fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
      decompose (Multiset.filter (fun p => p.1 = q) (a ::ₘ s)) intro a x ihcons𝓩:Typeinst✝:DecidableEq 𝓩q:𝓩a:𝓩 × Fluxesx:Multiset (𝓩 × Fluxes)ih:Multiset.filter (fun p => p.1 = q) (x.bind fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
  decompose (Multiset.filter (fun p => p.1 = q) x)⊢ Multiset.filter (fun p => p.1 = q) ((a ::ₘ x).bind fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
  decompose (Multiset.filter (fun p => p.1 = q) (a ::ₘ x))
    simp only [Multiset.cons_bind, Multiset.filter_add]cons𝓩:Typeinst✝:DecidableEq 𝓩q:𝓩a:𝓩 × Fluxesx:Multiset (𝓩 × Fluxes)ih:Multiset.filter (fun p => p.1 = q) (x.bind fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
  decompose (Multiset.filter (fun p => p.1 = q) x)⊢ Multiset.filter (fun p => p.1 = q) (Multiset.map (fun f => (a.1, f)) (decomposeFluxes a.2)) +
    Multiset.filter (fun p => p.1 = q) (x.bind fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
  decompose (Multiset.filter (fun p => p.1 = q) (a ::ₘ x))
    rw [Multiset.filter_cons,cons𝓩:Typeinst✝:DecidableEq 𝓩q:𝓩a:𝓩 × Fluxesx:Multiset (𝓩 × Fluxes)ih:Multiset.filter (fun p => p.1 = q) (x.bind fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
  decompose (Multiset.filter (fun p => p.1 = q) x)⊢ Multiset.filter (fun p => p.1 = q) (Multiset.map (fun f => (a.1, f)) (decomposeFluxes a.2)) +
    Multiset.filter (fun p => p.1 = q) (x.bind fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
  decompose ((if a.1 = q then {a} else 0) + Multiset.filter (fun p => p.1 = q) x)cons𝓩:Typeinst✝:DecidableEq 𝓩q:𝓩a:𝓩 × Fluxesx:Multiset (𝓩 × Fluxes)ih:Multiset.filter (fun p => p.1 = q) (x.bind fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
  decompose (Multiset.filter (fun p => p.1 = q) x)⊢ Multiset.filter (fun p => p.1 = q) (Multiset.map (fun f => (a.1, f)) (decomposeFluxes a.2)) +
    decompose (Multiset.filter (fun p => p.1 = q) x) =
  decompose (if a.1 = q then {a} else 0) + decompose (Multiset.filter (fun p => p.1 = q) x) decompose_add,cons𝓩:Typeinst✝:DecidableEq 𝓩q:𝓩a:𝓩 × Fluxesx:Multiset (𝓩 × Fluxes)ih:Multiset.filter (fun p => p.1 = q) (x.bind fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
  decompose (Multiset.filter (fun p => p.1 = q) x)⊢ Multiset.filter (fun p => p.1 = q) (Multiset.map (fun f => (a.1, f)) (decomposeFluxes a.2)) +
    Multiset.filter (fun p => p.1 = q) (x.bind fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
  decompose (if a.1 = q then {a} else 0) + decompose (Multiset.filter (fun p => p.1 = q) x)cons𝓩:Typeinst✝:DecidableEq 𝓩q:𝓩a:𝓩 × Fluxesx:Multiset (𝓩 × Fluxes)ih:Multiset.filter (fun p => p.1 = q) (x.bind fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
  decompose (Multiset.filter (fun p => p.1 = q) x)⊢ Multiset.filter (fun p => p.1 = q) (Multiset.map (fun f => (a.1, f)) (decomposeFluxes a.2)) +
    decompose (Multiset.filter (fun p => p.1 = q) x) =
  decompose (if a.1 = q then {a} else 0) + decompose (Multiset.filter (fun p => p.1 = q) x) ihcons𝓩:Typeinst✝:DecidableEq 𝓩q:𝓩a:𝓩 × Fluxesx:Multiset (𝓩 × Fluxes)ih:Multiset.filter (fun p => p.1 = q) (x.bind fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
  decompose (Multiset.filter (fun p => p.1 = q) x)⊢ Multiset.filter (fun p => p.1 = q) (Multiset.map (fun f => (a.1, f)) (decomposeFluxes a.2)) +
    decompose (Multiset.filter (fun p => p.1 = q) x) =
  decompose (if a.1 = q then {a} else 0) + decompose (Multiset.filter (fun p => p.1 = q) x)cons𝓩:Typeinst✝:DecidableEq 𝓩q:𝓩a:𝓩 × Fluxesx:Multiset (𝓩 × Fluxes)ih:Multiset.filter (fun p => p.1 = q) (x.bind fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
  decompose (Multiset.filter (fun p => p.1 = q) x)⊢ Multiset.filter (fun p => p.1 = q) (Multiset.map (fun f => (a.1, f)) (decomposeFluxes a.2)) +
    decompose (Multiset.filter (fun p => p.1 = q) x) =
  decompose (if a.1 = q then {a} else 0) + decompose (Multiset.filter (fun p => p.1 = q) x)]cons𝓩:Typeinst✝:DecidableEq 𝓩q:𝓩a:𝓩 × Fluxesx:Multiset (𝓩 × Fluxes)ih:Multiset.filter (fun p => p.1 = q) (x.bind fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
  decompose (Multiset.filter (fun p => p.1 = q) x)⊢ Multiset.filter (fun p => p.1 = q) (Multiset.map (fun f => (a.1, f)) (decomposeFluxes a.2)) +
    decompose (Multiset.filter (fun p => p.1 = q) x) =
  decompose (if a.1 = q then {a} else 0) + decompose (Multiset.filter (fun p => p.1 = q) x)
    congrcons.e_a𝓩:Typeinst✝:DecidableEq 𝓩q:𝓩a:𝓩 × Fluxesx:Multiset (𝓩 × Fluxes)ih:Multiset.filter (fun p => p.1 = q) (x.bind fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
  decompose (Multiset.filter (fun p => p.1 = q) x)⊢ Multiset.filter (fun p => p.1 = q) (Multiset.map (fun f => (a.1, f)) (decomposeFluxes a.2)) =
  decompose (if a.1 = q then {a} else 0)
    obtain ⟨q', f⟩ := acons.e_a𝓩:Typeinst✝:DecidableEq 𝓩q:𝓩x:Multiset (𝓩 × Fluxes)ih:Multiset.filter (fun p => p.1 = q) (x.bind fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
  decompose (Multiset.filter (fun p => p.1 = q) x)q':𝓩f:Fluxes⊢ Multiset.filter (fun p => p.1 = q) (Multiset.map (fun f_1 => ((q', f).1, f_1)) (decomposeFluxes (q', f).2)) =
  decompose (if (q', f).1 = q then {(q', f)} else 0)
    simp [decomposeFluxes]cons.e_a𝓩:Typeinst✝:DecidableEq 𝓩q:𝓩x:Multiset (𝓩 × Fluxes)ih:Multiset.filter (fun p => p.1 = q) (x.bind fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
  decompose (Multiset.filter (fun p => p.1 = q) x)q':𝓩f:Fluxes⊢ Multiset.filter (fun p => p.1 = q)
    (Multiset.map (fun x => (q', x))
      (if f = { M := 1, N := 0 } then {{ M := 1, N := 0 }}
      else
        if f = { M := 1, N := 1 } then {{ M := 1, N := 1 }}
        else
          if f = { M := 1, N := -1 } then {{ M := 1, N := -1 }}
          else
            if f = { M := 2, N := 1 } then { M := 1, N := 1 } ::ₘ {{ M := 1, N := 0 }}
            else
              if f = { M := 2, N := -1 } then { M := 1, N := -1 } ::ₘ {{ M := 1, N := 0 }}
              else
                if f = { M := 3, N := 0 } then { M := 1, N := 0 } ::ₘ { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }}
                else if f = { M := 2, N := 0 } then { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }} else {f})) =
  decompose (if q' = q then {(q', f)} else 0)
    by_cases h : q' = qpos𝓩:Typeinst✝:DecidableEq 𝓩q:𝓩x:Multiset (𝓩 × Fluxes)ih:Multiset.filter (fun p => p.1 = q) (x.bind fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
  decompose (Multiset.filter (fun p => p.1 = q) x)q':𝓩f:Fluxesh:q' = q⊢ Multiset.filter (fun p => p.1 = q)
    (Multiset.map (fun x => (q', x))
      (if f = { M := 1, N := 0 } then {{ M := 1, N := 0 }}
      else
        if f = { M := 1, N := 1 } then {{ M := 1, N := 1 }}
        else
          if f = { M := 1, N := -1 } then {{ M := 1, N := -1 }}
          else
            if f = { M := 2, N := 1 } then { M := 1, N := 1 } ::ₘ {{ M := 1, N := 0 }}
            else
              if f = { M := 2, N := -1 } then { M := 1, N := -1 } ::ₘ {{ M := 1, N := 0 }}
              else
                if f = { M := 3, N := 0 } then { M := 1, N := 0 } ::ₘ { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }}
                else if f = { M := 2, N := 0 } then { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }} else {f})) =
  decompose (if q' = q then {(q', f)} else 0)neg𝓩:Typeinst✝:DecidableEq 𝓩q:𝓩x:Multiset (𝓩 × Fluxes)ih:Multiset.filter (fun p => p.1 = q) (x.bind fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
  decompose (Multiset.filter (fun p => p.1 = q) x)q':𝓩f:Fluxesh:¬q' = q⊢ Multiset.filter (fun p => p.1 = q)
    (Multiset.map (fun x => (q', x))
      (if f = { M := 1, N := 0 } then {{ M := 1, N := 0 }}
      else
        if f = { M := 1, N := 1 } then {{ M := 1, N := 1 }}
        else
          if f = { M := 1, N := -1 } then {{ M := 1, N := -1 }}
          else
            if f = { M := 2, N := 1 } then { M := 1, N := 1 } ::ₘ {{ M := 1, N := 0 }}
            else
              if f = { M := 2, N := -1 } then { M := 1, N := -1 } ::ₘ {{ M := 1, N := 0 }}
              else
                if f = { M := 3, N := 0 } then { M := 1, N := 0 } ::ₘ { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }}
                else if f = { M := 2, N := 0 } then { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }} else {f})) =
  decompose (if q' = q then {(q', f)} else 0)
    ·pos𝓩:Typeinst✝:DecidableEq 𝓩q:𝓩x:Multiset (𝓩 × Fluxes)ih:Multiset.filter (fun p => p.1 = q) (x.bind fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
  decompose (Multiset.filter (fun p => p.1 = q) x)q':𝓩f:Fluxesh:q' = q⊢ Multiset.filter (fun p => p.1 = q)
    (Multiset.map (fun x => (q', x))
      (if f = { M := 1, N := 0 } then {{ M := 1, N := 0 }}
      else
        if f = { M := 1, N := 1 } then {{ M := 1, N := 1 }}
        else
          if f = { M := 1, N := -1 } then {{ M := 1, N := -1 }}
          else
            if f = { M := 2, N := 1 } then { M := 1, N := 1 } ::ₘ {{ M := 1, N := 0 }}
            else
              if f = { M := 2, N := -1 } then { M := 1, N := -1 } ::ₘ {{ M := 1, N := 0 }}
              else
                if f = { M := 3, N := 0 } then { M := 1, N := 0 } ::ₘ { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }}
                else if f = { M := 2, N := 0 } then { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }} else {f})) =
  decompose (if q' = q then {(q', f)} else 0) subst hpos𝓩:Typeinst✝:DecidableEq 𝓩x:Multiset (𝓩 × Fluxes)q':𝓩f:Fluxesih:Multiset.filter (fun p => p.1 = q') (x.bind fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
  decompose (Multiset.filter (fun p => p.1 = q') x)⊢ Multiset.filter (fun p => p.1 = q')
    (Multiset.map (fun x => (q', x))
      (if f = { M := 1, N := 0 } then {{ M := 1, N := 0 }}
      else
        if f = { M := 1, N := 1 } then {{ M := 1, N := 1 }}
        else
          if f = { M := 1, N := -1 } then {{ M := 1, N := -1 }}
          else
            if f = { M := 2, N := 1 } then { M := 1, N := 1 } ::ₘ {{ M := 1, N := 0 }}
            else
              if f = { M := 2, N := -1 } then { M := 1, N := -1 } ::ₘ {{ M := 1, N := 0 }}
              else
                if f = { M := 3, N := 0 } then { M := 1, N := 0 } ::ₘ { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }}
                else if f = { M := 2, N := 0 } then { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }} else {f})) =
  decompose (if q' = q' then {(q', f)} else 0)
      simp [decompose, decomposeFluxes]All goals completed! 🐙
    ·neg𝓩:Typeinst✝:DecidableEq 𝓩q:𝓩x:Multiset (𝓩 × Fluxes)ih:Multiset.filter (fun p => p.1 = q) (x.bind fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
  decompose (Multiset.filter (fun p => p.1 = q) x)q':𝓩f:Fluxesh:¬q' = q⊢ Multiset.filter (fun p => p.1 = q)
    (Multiset.map (fun x => (q', x))
      (if f = { M := 1, N := 0 } then {{ M := 1, N := 0 }}
      else
        if f = { M := 1, N := 1 } then {{ M := 1, N := 1 }}
        else
          if f = { M := 1, N := -1 } then {{ M := 1, N := -1 }}
          else
            if f = { M := 2, N := 1 } then { M := 1, N := 1 } ::ₘ {{ M := 1, N := 0 }}
            else
              if f = { M := 2, N := -1 } then { M := 1, N := -1 } ::ₘ {{ M := 1, N := 0 }}
              else
                if f = { M := 3, N := 0 } then { M := 1, N := 0 } ::ₘ { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }}
                else if f = { M := 2, N := 0 } then { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }} else {f})) =
  decompose (if q' = q then {(q', f)} else 0) simp [h, decompose]All goals completed! 🐙

C.2.3. Decomposition preserves the charge map



lemma decompose_toChargeMap [DecidableEq 𝓩] (x : TenQuanta 𝓩)
    (hx : x.toFluxesTen ∈ FluxesTen.elemsNoExotics) :
    x.decompose.toChargeMap = x.toChargeMap := by𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ x.decompose.toChargeMap = x.toChargeMap
  ext q𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩⊢ x.decompose.toChargeMap q = x.toChargeMap q
  rw [toChargeMap,𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩⊢ (Multiset.map Prod.snd (Multiset.filter (fun p => p.1 = q) x.decompose)).sum = x.toChargeMap q𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩⊢ (Multiset.map Prod.snd (decompose (Multiset.filter (fun p => p.1 = q) x))).sum = x.toChargeMap q decompose_filter_charge𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩⊢ (Multiset.map Prod.snd (decompose (Multiset.filter (fun p => p.1 = q) x))).sum = x.toChargeMap q𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩⊢ (Multiset.map Prod.snd (decompose (Multiset.filter (fun p => p.1 = q) x))).sum = x.toChargeMap q]𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩⊢ (Multiset.map Prod.snd (decompose (Multiset.filter (fun p => p.1 = q) x))).sum = x.toChargeMap q
  simp [decompose]𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩⊢ (Multiset.map Prod.snd
      ((Multiset.filter (fun p => p.1 = q) x).bind fun p =>
        Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2))).sum =
  x.toChargeMap q
  rw [Multiset.map_bind𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩⊢ ((Multiset.filter (fun p => p.1 = q) x).bind fun a =>
      Multiset.map Prod.snd (Multiset.map (fun f => (a.1, f)) (decomposeFluxes a.2))).sum =
  x.toChargeMap q𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩⊢ ((Multiset.filter (fun p => p.1 = q) x).bind fun a =>
      Multiset.map Prod.snd (Multiset.map (fun f => (a.1, f)) (decomposeFluxes a.2))).sum =
  x.toChargeMap q]𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩⊢ ((Multiset.filter (fun p => p.1 = q) x).bind fun a =>
      Multiset.map Prod.snd (Multiset.map (fun f => (a.1, f)) (decomposeFluxes a.2))).sum =
  x.toChargeMap q
  simp only [Multiset.map_map, Function.comp_apply, Multiset.map_id', Multiset.sum_bind]𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩⊢ (Multiset.map (fun a => (decomposeFluxes a.2).sum) (Multiset.filter (fun p => p.1 = q) x)).sum = x.toChargeMap q
  rw [toChargeMap𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩⊢ (Multiset.map (fun a => (decomposeFluxes a.2).sum) (Multiset.filter (fun p => p.1 = q) x)).sum =
  (Multiset.map Prod.snd (Multiset.filter (fun p => p.1 = q) x)).sum𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩⊢ (Multiset.map (fun a => (decomposeFluxes a.2).sum) (Multiset.filter (fun p => p.1 = q) x)).sum =
  (Multiset.map Prod.snd (Multiset.filter (fun p => p.1 = q) x)).sum]𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩⊢ (Multiset.map (fun a => (decomposeFluxes a.2).sum) (Multiset.filter (fun p => p.1 = q) x)).sum =
  (Multiset.map Prod.snd (Multiset.filter (fun p => p.1 = q) x)).sum
  congr 1𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩⊢ Multiset.map (fun a => (decomposeFluxes a.2).sum) (Multiset.filter (fun p => p.1 = q) x) =
  Multiset.map Prod.snd (Multiset.filter (fun p => p.1 = q) x)
  refine Multiset.map_congr rfl fun a ha => ?_𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩a:𝓩 × Fluxesha:a ∈ Multiset.filter (fun p => p.1 = q) x⊢ (decomposeFluxes a.2).sum = a.2
  apply decomposeFluxes_sum_of_noExotics𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩a:𝓩 × Fluxesha:a ∈ Multiset.filter (fun p => p.1 = q) x⊢ ∃ F ∈ FluxesTen.elemsNoExotics, a.2 ∈ F
  use x.toFluxesTenh𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩a:𝓩 × Fluxesha:a ∈ Multiset.filter (fun p => p.1 = q) x⊢ x.toFluxesTen ∈ FluxesTen.elemsNoExotics ∧ a.2 ∈ x.toFluxesTen
  simp_all [toFluxesTen]h𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩a:𝓩 × Fluxeshx:Multiset.map Prod.snd x ∈ FluxesTen.elemsNoExoticsha:a ∈ x ∧ a.1 = q⊢ ∃ a_1, (a_1, a.2) ∈ x
  use a.1h𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩a:𝓩 × Fluxeshx:Multiset.map Prod.snd x ∈ FluxesTen.elemsNoExoticsha:a ∈ x ∧ a.1 = q⊢ (a.1, a.2) ∈ x
  exact ha.1All goals completed! 🐙

C.2.4. Decomposition preserves the charges



lemma decompose_toCharges_dedup [DecidableEq 𝓩] (x : TenQuanta 𝓩)
    (hx : x.toFluxesTen ∈ FluxesTen.elemsNoExotics) :
    x.decompose.toCharges.dedup = x.toCharges.dedup := by𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ x.decompose.toCharges.dedup = x.toCharges.dedup
  refine Multiset.dedup_ext.mpr ?_𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ ∀ (a : 𝓩), a ∈ x.decompose.toCharges ↔ a ∈ x.toCharges
  intro q𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩⊢ q ∈ x.decompose.toCharges ↔ q ∈ x.toCharges
  simp [decompose, toCharges, -existsAndEq]𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩⊢ (∃ x_1 a b, (a, b) ∈ x ∧ x_1 ∈ decomposeFluxes b ∧ a = q) ↔ ∃ x_1, (q, x_1) ∈ x
  constructormp𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩⊢ (∃ x_1 a b, (a, b) ∈ x ∧ x_1 ∈ decomposeFluxes b ∧ a = q) → ∃ x_1, (q, x_1) ∈ xmpr𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩⊢ (∃ x_1, (q, x_1) ∈ x) → ∃ x_1 a b, (a, b) ∈ x ∧ x_1 ∈ decomposeFluxes b ∧ a = q
  ·mp𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩⊢ (∃ x_1 a b, (a, b) ∈ x ∧ x_1 ∈ decomposeFluxes b ∧ a = q) → ∃ x_1, (q, x_1) ∈ x rintro ⟨a, b, c, h1, h2, rfl⟩mp𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsa:Fluxesb:𝓩c:Fluxesh1:(b, c) ∈ xh2:a ∈ decomposeFluxes c⊢ ∃ x_1, (b, x_1) ∈ x
    exact ⟨c, h1⟩All goals completed! 🐙
  ·mpr𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩⊢ (∃ x_1, (q, x_1) ∈ x) → ∃ x_1 a b, (a, b) ∈ x ∧ x_1 ∈ decomposeFluxes b ∧ a = q rintro ⟨c, h1⟩mpr𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩c:Fluxesh1:(q, c) ∈ x⊢ ∃ x_1 a b, (a, b) ∈ x ∧ x_1 ∈ decomposeFluxes b ∧ a = q
    have hn : (decomposeFluxes c) ≠ 0 := by𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ x.decompose.toCharges.dedup = x.toCharges.dedupmpr𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩c:Fluxesh1:(q, c) ∈ xhn:decomposeFluxes c ≠ 0⊢ ∃ x_1 a b, (a, b) ∈ x ∧ x_1 ∈ decomposeFluxes b ∧ a = q
      have c_mem_f : c ∈ x.toFluxesTen := by𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ x.decompose.toCharges.dedup = x.toCharges.dedup𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩c:Fluxesh1:(q, c) ∈ xc_mem_f:c ∈ x.toFluxesTen⊢ decomposeFluxes c ≠ 0mpr𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩c:Fluxesh1:(q, c) ∈ xhn:decomposeFluxes c ≠ 0⊢ ∃ x_1 a b, (a, b) ∈ x ∧ x_1 ∈ decomposeFluxes b ∧ a = q
        simp [toFluxesTen]𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩c:Fluxesh1:(q, c) ∈ x⊢ ∃ a, (a, c) ∈ x𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩c:Fluxesh1:(q, c) ∈ xc_mem_f:c ∈ x.toFluxesTen⊢ decomposeFluxes c ≠ 0mpr𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩c:Fluxesh1:(q, c) ∈ xhn:decomposeFluxes c ≠ 0⊢ ∃ x_1 a b, (a, b) ∈ x ∧ x_1 ∈ decomposeFluxes b ∧ a = q
        use q𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩c:Fluxesh1:(q, c) ∈ xc_mem_f:c ∈ x.toFluxesTen⊢ decomposeFluxes c ≠ 0mpr𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩c:Fluxesh1:(q, c) ∈ xhn:decomposeFluxes c ≠ 0⊢ ∃ x_1 a b, (a, b) ∈ x ∧ x_1 ∈ decomposeFluxes b ∧ a = q𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩c:Fluxesh1:(q, c) ∈ xc_mem_f:c ∈ x.toFluxesTen⊢ decomposeFluxes c ≠ 0mpr𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩c:Fluxesh1:(q, c) ∈ xhn:decomposeFluxes c ≠ 0⊢ ∃ x_1 a b, (a, b) ∈ x ∧ x_1 ∈ decomposeFluxes b ∧ a = q
      generalize x.toFluxesTen = F at *𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩c:Fluxesh1:(q, c) ∈ xF:FluxesTenhx:F ∈ FluxesTen.elemsNoExoticsc_mem_f:c ∈ F⊢ decomposeFluxes c ≠ 0mpr𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩c:Fluxesh1:(q, c) ∈ xhn:decomposeFluxes c ≠ 0⊢ ∃ x_1 a b, (a, b) ∈ x ∧ x_1 ∈ decomposeFluxes b ∧ a = q
      clear h1𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩c:FluxesF:FluxesTenhx:F ∈ FluxesTen.elemsNoExoticsc_mem_f:c ∈ F⊢ decomposeFluxes c ≠ 0mpr𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩c:Fluxesh1:(q, c) ∈ xhn:decomposeFluxes c ≠ 0⊢ ∃ x_1 a b, (a, b) ∈ x ∧ x_1 ∈ decomposeFluxes b ∧ a = q
      revert c𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩F:FluxesTenhx:F ∈ FluxesTen.elemsNoExotics⊢ ∀ c ∈ F, decomposeFluxes c ≠ 0mpr𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩c:Fluxesh1:(q, c) ∈ xhn:decomposeFluxes c ≠ 0⊢ ∃ x_1 a b, (a, b) ∈ x ∧ x_1 ∈ decomposeFluxes b ∧ a = q
      revert F𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩q:𝓩⊢ ∀ F ∈ FluxesTen.elemsNoExotics, ∀ c ∈ F, decomposeFluxes c ≠ 0mpr𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩c:Fluxesh1:(q, c) ∈ xhn:decomposeFluxes c ≠ 0⊢ ∃ x_1 a b, (a, b) ∈ x ∧ x_1 ∈ decomposeFluxes b ∧ a = q
      decidempr𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩c:Fluxesh1:(q, c) ∈ xhn:decomposeFluxes c ≠ 0⊢ ∃ x_1 a b, (a, b) ∈ x ∧ x_1 ∈ decomposeFluxes b ∧ a = qmpr𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩c:Fluxesh1:(q, c) ∈ xhn:decomposeFluxes c ≠ 0⊢ ∃ x_1 a b, (a, b) ∈ x ∧ x_1 ∈ decomposeFluxes b ∧ a = q
    apply Multiset.exists_mem_of_ne_zero at hnmpr𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩c:Fluxesh1:(q, c) ∈ xhn:∃ a, a ∈ decomposeFluxes c⊢ ∃ x_1 a b, (a, b) ∈ x ∧ x_1 ∈ decomposeFluxes b ∧ a = q
    obtain ⟨c', h⟩ := hnmpr𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩c:Fluxesh1:(q, c) ∈ xc':Fluxesh:c' ∈ decomposeFluxes c⊢ ∃ x_1 a b, (a, b) ∈ x ∧ x_1 ∈ decomposeFluxes b ∧ a = q
    use c', q, cAll goals completed! 🐙

C.2.5. Decomposition preserves the reduction



lemma decompose_reduce (x : TenQuanta 𝓩) [DecidableEq 𝓩]
    (hx : x.toFluxesTen ∈ FluxesTen.elemsNoExotics) :
    x.decompose.reduce = x.reduce := by𝓩:Typex:TenQuanta 𝓩inst✝:DecidableEq 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ x.decompose.reduce = x.reduce
  rw [reduce,𝓩:Typex:TenQuanta 𝓩inst✝:DecidableEq 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ Multiset.map (fun q10 => (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x.decompose)).sum))
    x.decompose.toCharges.dedup =
  x.reduce𝓩:Typex:TenQuanta 𝓩inst✝:DecidableEq 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ Multiset.map (fun q10 => (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x.decompose)).sum))
    x.decompose.toCharges.dedup =
  Multiset.map (fun q10 => (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x)).sum))
    x.toCharges.dedup reduce𝓩:Typex:TenQuanta 𝓩inst✝:DecidableEq 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ Multiset.map (fun q10 => (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x.decompose)).sum))
    x.decompose.toCharges.dedup =
  Multiset.map (fun q10 => (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x)).sum))
    x.toCharges.dedup𝓩:Typex:TenQuanta 𝓩inst✝:DecidableEq 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ Multiset.map (fun q10 => (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x.decompose)).sum))
    x.decompose.toCharges.dedup =
  Multiset.map (fun q10 => (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x)).sum))
    x.toCharges.dedup]𝓩:Typex:TenQuanta 𝓩inst✝:DecidableEq 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ Multiset.map (fun q10 => (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x.decompose)).sum))
    x.decompose.toCharges.dedup =
  Multiset.map (fun q10 => (q10, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q10) x)).sum))
    x.toCharges.dedup
  refine Multiset.map_congr (decompose_toCharges_dedup x hx) fun q hx' => ?_𝓩:Typex:TenQuanta 𝓩inst✝:DecidableEq 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩hx':q ∈ x.toCharges.dedup⊢ (q, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q) x.decompose)).sum) =
  (q, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q) x)).sum)
  simp only [Prod.mk.injEq, true_and]𝓩:Typex:TenQuanta 𝓩inst✝:DecidableEq 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩hx':q ∈ x.toCharges.dedup⊢ (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q) x.decompose)).sum =
  (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q) x)).sum
  change x.decompose.toChargeMap q = x.toChargeMap q𝓩:Typex:TenQuanta 𝓩inst✝:DecidableEq 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩hx':q ∈ x.toCharges.dedup⊢ x.decompose.toChargeMap q = x.toChargeMap q
  rw [decompose_toChargeMap x hx𝓩:Typex:TenQuanta 𝓩inst✝:DecidableEq 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsq:𝓩hx':q ∈ x.toCharges.dedup⊢ x.toChargeMap q = x.toChargeMap qAll goals completed! 🐙]All goals completed! 🐙

C.2.6. Fluxes of the decomposition of a `TenQuanta`



lemma decompose_toFluxesTen (x : TenQuanta 𝓩)
    (hx : x.toFluxesTen ∈ FluxesTen.elemsNoExotics) :
    x.decompose.toFluxesTen = {⟨1, 0⟩, ⟨1, 0⟩, ⟨1, 0⟩} ∨
    x.decompose.toFluxesTen = {⟨1, 1⟩, ⟨1, -1⟩, ⟨1, 0⟩} := by𝓩:Typex:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ x.decompose.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
  x.decompose.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}
  rw [toFluxesTen,𝓩:Typex:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ Multiset.map Prod.snd x.decompose = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
  Multiset.map Prod.snd x.decompose = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}𝓩:Typex:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ Multiset.map Prod.snd (Multiset.bind x fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
    {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
  Multiset.map Prod.snd (Multiset.bind x fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
    {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }} decompose𝓩:Typex:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ Multiset.map Prod.snd (Multiset.bind x fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
    {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
  Multiset.map Prod.snd (Multiset.bind x fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
    {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}𝓩:Typex:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ Multiset.map Prod.snd (Multiset.bind x fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
    {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
  Multiset.map Prod.snd (Multiset.bind x fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
    {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}]𝓩:Typex:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ Multiset.map Prod.snd (Multiset.bind x fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
    {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
  Multiset.map Prod.snd (Multiset.bind x fun p => Multiset.map (fun f => (p.1, f)) (decomposeFluxes p.2)) =
    {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}
  rw [Multiset.map_bind𝓩:Typex:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ (Multiset.bind x fun a => Multiset.map Prod.snd (Multiset.map (fun f => (a.1, f)) (decomposeFluxes a.2))) =
    {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
  (Multiset.bind x fun a => Multiset.map Prod.snd (Multiset.map (fun f => (a.1, f)) (decomposeFluxes a.2))) =
    {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}𝓩:Typex:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ (Multiset.bind x fun a => Multiset.map Prod.snd (Multiset.map (fun f => (a.1, f)) (decomposeFluxes a.2))) =
    {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
  (Multiset.bind x fun a => Multiset.map Prod.snd (Multiset.map (fun f => (a.1, f)) (decomposeFluxes a.2))) =
    {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}]𝓩:Typex:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ (Multiset.bind x fun a => Multiset.map Prod.snd (Multiset.map (fun f => (a.1, f)) (decomposeFluxes a.2))) =
    {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
  (Multiset.bind x fun a => Multiset.map Prod.snd (Multiset.map (fun f => (a.1, f)) (decomposeFluxes a.2))) =
    {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}
  simp only [Multiset.map_map, Function.comp_apply, Multiset.map_id', Multiset.insert_eq_cons,
    Int.reduceNeg]𝓩:Typex:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ (Multiset.bind x fun a => decomposeFluxes a.2) = { M := 1, N := 0 } ::ₘ { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }} ∨
  (Multiset.bind x fun a => decomposeFluxes a.2) = { M := 1, N := 1 } ::ₘ { M := 1, N := -1 } ::ₘ {{ M := 1, N := 0 }}
  have hx : (Multiset.bind x fun a => decomposeFluxes a.2) =
      (Multiset.bind x.toFluxesTen fun a => decomposeFluxes a) := by𝓩:Typex:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ x.decompose.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
  x.decompose.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}𝓩:Typex:TenQuanta 𝓩hx✝:x.toFluxesTen ∈ FluxesTen.elemsNoExoticshx:(Multiset.bind x fun a => decomposeFluxes a.2) = Multiset.bind x.toFluxesTen fun a => decomposeFluxes a⊢ (Multiset.bind x fun a => decomposeFluxes a.2) = { M := 1, N := 0 } ::ₘ { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }} ∨
  (Multiset.bind x fun a => decomposeFluxes a.2) = { M := 1, N := 1 } ::ₘ { M := 1, N := -1 } ::ₘ {{ M := 1, N := 0 }}
    rw [toFluxesTen,𝓩:Typex:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ (Multiset.bind x fun a => decomposeFluxes a.2) = (Multiset.map Prod.snd x).bind fun a => decomposeFluxes a𝓩:Typex:TenQuanta 𝓩hx✝:x.toFluxesTen ∈ FluxesTen.elemsNoExoticshx:(Multiset.bind x fun a => decomposeFluxes a.2) = Multiset.bind x.toFluxesTen fun a => decomposeFluxes a⊢ (Multiset.bind x fun a => decomposeFluxes a.2) = { M := 1, N := 0 } ::ₘ { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }} ∨
  (Multiset.bind x fun a => decomposeFluxes a.2) = { M := 1, N := 1 } ::ₘ { M := 1, N := -1 } ::ₘ {{ M := 1, N := 0 }} Multiset.bind_map𝓩:Typex:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ (Multiset.bind x fun a => decomposeFluxes a.2) = Multiset.bind x fun a => decomposeFluxes a.2𝓩:Typex:TenQuanta 𝓩hx✝:x.toFluxesTen ∈ FluxesTen.elemsNoExoticshx:(Multiset.bind x fun a => decomposeFluxes a.2) = Multiset.bind x.toFluxesTen fun a => decomposeFluxes a⊢ (Multiset.bind x fun a => decomposeFluxes a.2) = { M := 1, N := 0 } ::ₘ { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }} ∨
  (Multiset.bind x fun a => decomposeFluxes a.2) = { M := 1, N := 1 } ::ₘ { M := 1, N := -1 } ::ₘ {{ M := 1, N := 0 }}]𝓩:Typex:TenQuanta 𝓩hx✝:x.toFluxesTen ∈ FluxesTen.elemsNoExoticshx:(Multiset.bind x fun a => decomposeFluxes a.2) = Multiset.bind x.toFluxesTen fun a => decomposeFluxes a⊢ (Multiset.bind x fun a => decomposeFluxes a.2) = { M := 1, N := 0 } ::ₘ { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }} ∨
  (Multiset.bind x fun a => decomposeFluxes a.2) = { M := 1, N := 1 } ::ₘ { M := 1, N := -1 } ::ₘ {{ M := 1, N := 0 }}𝓩:Typex:TenQuanta 𝓩hx✝:x.toFluxesTen ∈ FluxesTen.elemsNoExoticshx:(Multiset.bind x fun a => decomposeFluxes a.2) = Multiset.bind x.toFluxesTen fun a => decomposeFluxes a⊢ (Multiset.bind x fun a => decomposeFluxes a.2) = { M := 1, N := 0 } ::ₘ { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }} ∨
  (Multiset.bind x fun a => decomposeFluxes a.2) = { M := 1, N := 1 } ::ₘ { M := 1, N := -1 } ::ₘ {{ M := 1, N := 0 }}
  rw [hx𝓩:Typex:TenQuanta 𝓩hx✝:x.toFluxesTen ∈ FluxesTen.elemsNoExoticshx:(Multiset.bind x fun a => decomposeFluxes a.2) = Multiset.bind x.toFluxesTen fun a => decomposeFluxes a⊢ (Multiset.bind x.toFluxesTen fun a => decomposeFluxes a) =
    { M := 1, N := 0 } ::ₘ { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }} ∨
  (Multiset.bind x.toFluxesTen fun a => decomposeFluxes a) =
    { M := 1, N := 1 } ::ₘ { M := 1, N := -1 } ::ₘ {{ M := 1, N := 0 }}𝓩:Typex:TenQuanta 𝓩hx✝:x.toFluxesTen ∈ FluxesTen.elemsNoExoticshx:(Multiset.bind x fun a => decomposeFluxes a.2) = Multiset.bind x.toFluxesTen fun a => decomposeFluxes a⊢ (Multiset.bind x.toFluxesTen fun a => decomposeFluxes a) =
    { M := 1, N := 0 } ::ₘ { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }} ∨
  (Multiset.bind x.toFluxesTen fun a => decomposeFluxes a) =
    { M := 1, N := 1 } ::ₘ { M := 1, N := -1 } ::ₘ {{ M := 1, N := 0 }}]𝓩:Typex:TenQuanta 𝓩hx✝:x.toFluxesTen ∈ FluxesTen.elemsNoExoticshx:(Multiset.bind x fun a => decomposeFluxes a.2) = Multiset.bind x.toFluxesTen fun a => decomposeFluxes a⊢ (Multiset.bind x.toFluxesTen fun a => decomposeFluxes a) =
    { M := 1, N := 0 } ::ₘ { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }} ∨
  (Multiset.bind x.toFluxesTen fun a => decomposeFluxes a) =
    { M := 1, N := 1 } ::ₘ { M := 1, N := -1 } ::ₘ {{ M := 1, N := 0 }}
  clear hx𝓩:Typex:TenQuanta 𝓩hx:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ (Multiset.bind x.toFluxesTen fun a => decomposeFluxes a) =
    { M := 1, N := 0 } ::ₘ { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }} ∨
  (Multiset.bind x.toFluxesTen fun a => decomposeFluxes a) =
    { M := 1, N := 1 } ::ₘ { M := 1, N := -1 } ::ₘ {{ M := 1, N := 0 }}
  generalize x.toFluxesTen = F at *𝓩:Typex:TenQuanta 𝓩F:FluxesTenhx:F ∈ FluxesTen.elemsNoExotics⊢ (Multiset.bind F fun a => decomposeFluxes a) = { M := 1, N := 0 } ::ₘ { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }} ∨
  (Multiset.bind F fun a => decomposeFluxes a) = { M := 1, N := 1 } ::ₘ { M := 1, N := -1 } ::ₘ {{ M := 1, N := 0 }}
  revert F𝓩:Typex:TenQuanta 𝓩⊢ ∀ F ∈ FluxesTen.elemsNoExotics,
  (Multiset.bind F fun a => decomposeFluxes a) = { M := 1, N := 0 } ::ₘ { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }} ∨
    (Multiset.bind F fun a => decomposeFluxes a) = { M := 1, N := 1 } ::ₘ { M := 1, N := -1 } ::ₘ {{ M := 1, N := 0 }}
  decideAll goals completed! 🐙

D. Lifting charges to `TenQuanta`

D.1. `liftCharge c`: multiset of ten-quanta for a finite set of charges `c` with no exotics

This is an efficient definition, we will later show that it gives the correct answer

Given a finite set of charges c the TenQuanta which do not have exotics, duplicate charges or zero fluxes, which map down to c. This is defined to be as efficient as possible.

def liftCharge (c : Finset 𝓩) : Multiset (TenQuanta 𝓩) :=
  /- The {(1, 0), (1, 0), (1, 0)} case. -/
  /- The multisets of cardinality 3 containing 3 elements of `c`. -/
  let S10 : Multiset (Multiset 𝓩) := toMultisetsThree c
  let F1 : Multiset (TenQuanta 𝓩) :=
    (S10.map (fun s => s.map (fun z => (z, ⟨1, 0⟩)))).filter (fun s => c.val ≤ s.toCharges)
  /- The {(1, 1), (1, -1), (1, 0)} case. -/
  let F2 : Multiset (TenQuanta 𝓩) := ((c.product <| c.product <| c).val.map
    fun (x, y, z) => {(x, ⟨1, 1⟩), (y, ⟨1, -1⟩), (z, ⟨1, 0⟩)}).filter (fun s => c.val ≤ s.toCharges)
  /- All together-/
  (F1 + F2).map reduce

D.2. TenQuanta in `liftCharge c` have a finite set of charges `c`



lemma toCharge_toFinset_of_mem_liftCharge (c : Finset 𝓩)
    {x : TenQuanta 𝓩} (h : x ∈ liftCharge c) :
    x.toCharges.toFinset = c := by𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x ∈ liftCharge c⊢ x.toCharges.toFinset = c
  rw [liftCharge,𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x ∈
  Multiset.map reduce
    (Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
      Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map
          (fun x =>
            match x with
            | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
          (c.product (c.product c)).val))⊢ x.toCharges.toFinset = c𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:∃
  a ∈
    Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
      Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map
          (fun x =>
            match x with
            | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
          (c.product (c.product c)).val),
  a.reduce = x⊢ x.toCharges.toFinset = c Multiset.mem_map𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:∃
  a ∈
    Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
      Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map
          (fun x =>
            match x with
            | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
          (c.product (c.product c)).val),
  a.reduce = x⊢ x.toCharges.toFinset = c𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:∃
  a ∈
    Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
      Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map
          (fun x =>
            match x with
            | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
          (c.product (c.product c)).val),
  a.reduce = x⊢ x.toCharges.toFinset = c] at h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:∃
  a ∈
    Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
      Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map
          (fun x =>
            match x with
            | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
          (c.product (c.product c)).val),
  a.reduce = x⊢ x.toCharges.toFinset = c
  obtain ⟨a, h, rfl⟩ := h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩a:TenQuanta 𝓩h:a ∈
  Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
    Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map
        (fun x =>
          match x with
          | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
        (c.product (c.product c)).val)⊢ a.reduce.toCharges.toFinset = c
  rw [reduce_toCharges𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩a:TenQuanta 𝓩h:a ∈
  Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
    Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map
        (fun x =>
          match x with
          | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
        (c.product (c.product c)).val)⊢ a.toCharges.dedup.toFinset = c𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩a:TenQuanta 𝓩h:a ∈
  Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
    Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map
        (fun x =>
          match x with
          | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
        (c.product (c.product c)).val)⊢ a.toCharges.dedup.toFinset = c]𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩a:TenQuanta 𝓩h:a ∈
  Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
    Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map
        (fun x =>
          match x with
          | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
        (c.product (c.product c)).val)⊢ a.toCharges.dedup.toFinset = c
  simp at h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩a:TenQuanta 𝓩h:(∃ a_1, (a_1.toFinset ⊆ c ∧ a_1.card = 3) ∧ Multiset.map (fun z => (z, { M := 1, N := 0 })) a_1 = a) ∧
    c.val ≤ a.toCharges ∨
  (∃ a_1 a_2 b,
      (a_1 ∈ c ∧ a_2 ∈ c ∧ b ∈ c) ∧
        (a_1, { M := 1, N := 1 }) ::ₘ (a_2, { M := 1, N := -1 }) ::ₘ {(b, { M := 1, N := 0 })} = a) ∧
    c.val ≤ a.toCharges⊢ a.toCharges.dedup.toFinset = c
  rcases h with h | hinl𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩a:TenQuanta 𝓩h:(∃ a_1, (a_1.toFinset ⊆ c ∧ a_1.card = 3) ∧ Multiset.map (fun z => (z, { M := 1, N := 0 })) a_1 = a) ∧
  c.val ≤ a.toCharges⊢ a.toCharges.dedup.toFinset = cinr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩a:TenQuanta 𝓩h:(∃ a_1 a_2 b,
    (a_1 ∈ c ∧ a_2 ∈ c ∧ b ∈ c) ∧
      (a_1, { M := 1, N := 1 }) ::ₘ (a_2, { M := 1, N := -1 }) ::ₘ {(b, { M := 1, N := 0 })} = a) ∧
  c.val ≤ a.toCharges⊢ a.toCharges.dedup.toFinset = c
  ·inl𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩a:TenQuanta 𝓩h:(∃ a_1, (a_1.toFinset ⊆ c ∧ a_1.card = 3) ∧ Multiset.map (fun z => (z, { M := 1, N := 0 })) a_1 = a) ∧
  c.val ≤ a.toCharges⊢ a.toCharges.dedup.toFinset = c obtain ⟨⟨s, h, rfl⟩, h'⟩ := hinl𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩s:Multiset 𝓩h:s.toFinset ⊆ c ∧ s.card = 3h':c.val ≤ toCharges (Multiset.map (fun z => (z, { M := 1, N := 0 })) s)⊢ (toCharges (Multiset.map (fun z => (z, { M := 1, N := 0 })) s)).dedup.toFinset = c
    simp_all [toCharges]inl𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩s:Multiset 𝓩h:s.toFinset ⊆ c ∧ s.card = 3h':c.val ≤ s⊢ s.toFinset = c
    ext ainl𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩s:Multiset 𝓩h:s.toFinset ⊆ c ∧ s.card = 3h':c.val ≤ sa:𝓩⊢ a ∈ s.toFinset ↔ a ∈ c
    simp only [Multiset.mem_toFinset]inl𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩s:Multiset 𝓩h:s.toFinset ⊆ c ∧ s.card = 3h':c.val ≤ sa:𝓩⊢ a ∈ s ↔ a ∈ c
    constructorinl.mp𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩s:Multiset 𝓩h:s.toFinset ⊆ c ∧ s.card = 3h':c.val ≤ sa:𝓩⊢ a ∈ s → a ∈ cinl.mpr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩s:Multiset 𝓩h:s.toFinset ⊆ c ∧ s.card = 3h':c.val ≤ sa:𝓩⊢ a ∈ c → a ∈ s
    ·inl.mp𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩s:Multiset 𝓩h:s.toFinset ⊆ c ∧ s.card = 3h':c.val ≤ sa:𝓩⊢ a ∈ s → a ∈ c intro hrinl.mp𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩s:Multiset 𝓩h:s.toFinset ⊆ c ∧ s.card = 3h':c.val ≤ sa:𝓩hr:a ∈ s⊢ a ∈ c
      apply h.1inl.mp𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩s:Multiset 𝓩h:s.toFinset ⊆ c ∧ s.card = 3h':c.val ≤ sa:𝓩hr:a ∈ s⊢ a ∈ s.toFinset
      simpa using hrAll goals completed! 🐙
    ·inl.mpr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩s:Multiset 𝓩h:s.toFinset ⊆ c ∧ s.card = 3h':c.val ≤ sa:𝓩⊢ a ∈ c → a ∈ s intro hrinl.mpr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩s:Multiset 𝓩h:s.toFinset ⊆ c ∧ s.card = 3h':c.val ≤ sa:𝓩hr:a ∈ c⊢ a ∈ s
      exact Multiset.mem_of_le h' hrAll goals completed! 🐙
  ·inr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩a:TenQuanta 𝓩h:(∃ a_1 a_2 b,
    (a_1 ∈ c ∧ a_2 ∈ c ∧ b ∈ c) ∧
      (a_1, { M := 1, N := 1 }) ::ₘ (a_2, { M := 1, N := -1 }) ::ₘ {(b, { M := 1, N := 0 })} = a) ∧
  c.val ≤ a.toCharges⊢ a.toCharges.dedup.toFinset = c obtain ⟨⟨q1, q2, q3, h, rfl⟩, h'⟩ := hinr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩q1:𝓩q2:𝓩q3:𝓩h:q1 ∈ c ∧ q2 ∈ c ∧ q3 ∈ ch':c.val ≤ toCharges ((q1, { M := 1, N := 1 }) ::ₘ (q2, { M := 1, N := -1 }) ::ₘ {(q3, { M := 1, N := 0 })})⊢ (toCharges ((q1, { M := 1, N := 1 }) ::ₘ (q2, { M := 1, N := -1 }) ::ₘ {(q3, { M := 1, N := 0 })})).dedup.toFinset = c
    simp_all [toCharges]inr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩q1:𝓩q2:𝓩q3:𝓩h:q1 ∈ c ∧ q2 ∈ c ∧ q3 ∈ ch':c.val ≤ q1 ::ₘ q2 ::ₘ {q3}⊢ {q1, q2, q3} = c
    refine Eq.symm (Finset.ext_iff.mpr ?_)inr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩q1:𝓩q2:𝓩q3:𝓩h:q1 ∈ c ∧ q2 ∈ c ∧ q3 ∈ ch':c.val ≤ q1 ::ₘ q2 ::ₘ {q3}⊢ ∀ (a : 𝓩), a ∈ c ↔ a ∈ {q1, q2, q3}
    intro ainr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩q1:𝓩q2:𝓩q3:𝓩h:q1 ∈ c ∧ q2 ∈ c ∧ q3 ∈ ch':c.val ≤ q1 ::ₘ q2 ::ₘ {q3}a:𝓩⊢ a ∈ c ↔ a ∈ {q1, q2, q3}
    constructorinr.mp𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩q1:𝓩q2:𝓩q3:𝓩h:q1 ∈ c ∧ q2 ∈ c ∧ q3 ∈ ch':c.val ≤ q1 ::ₘ q2 ::ₘ {q3}a:𝓩⊢ a ∈ c → a ∈ {q1, q2, q3}inr.mpr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩q1:𝓩q2:𝓩q3:𝓩h:q1 ∈ c ∧ q2 ∈ c ∧ q3 ∈ ch':c.val ≤ q1 ::ₘ q2 ::ₘ {q3}a:𝓩⊢ a ∈ {q1, q2, q3} → a ∈ c
    ·inr.mp𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩q1:𝓩q2:𝓩q3:𝓩h:q1 ∈ c ∧ q2 ∈ c ∧ q3 ∈ ch':c.val ≤ q1 ::ₘ q2 ::ₘ {q3}a:𝓩⊢ a ∈ c → a ∈ {q1, q2, q3} intro hrinr.mp𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩q1:𝓩q2:𝓩q3:𝓩h:q1 ∈ c ∧ q2 ∈ c ∧ q3 ∈ ch':c.val ≤ q1 ::ₘ q2 ::ₘ {q3}a:𝓩hr:a ∈ c⊢ a ∈ {q1, q2, q3}
      simpa using Multiset.mem_of_le h' hrAll goals completed! 🐙
    ·inr.mpr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩q1:𝓩q2:𝓩q3:𝓩h:q1 ∈ c ∧ q2 ∈ c ∧ q3 ∈ ch':c.val ≤ q1 ::ₘ q2 ::ₘ {q3}a:𝓩⊢ a ∈ {q1, q2, q3} → a ∈ c intro hrinr.mpr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩q1:𝓩q2:𝓩q3:𝓩h:q1 ∈ c ∧ q2 ∈ c ∧ q3 ∈ ch':c.val ≤ q1 ::ₘ q2 ::ₘ {q3}a:𝓩hr:a ∈ {q1, q2, q3}⊢ a ∈ c
      simp at hrinr.mpr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩q1:𝓩q2:𝓩q3:𝓩h:q1 ∈ c ∧ q2 ∈ c ∧ q3 ∈ ch':c.val ≤ q1 ::ₘ q2 ::ₘ {q3}a:𝓩hr:a = q1 ∨ a = q2 ∨ a = q3⊢ a ∈ c
      rcases hr with rfl | rfl | rflinr.mpr.inl𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩q2:𝓩q3:𝓩a:𝓩h:a ∈ c ∧ q2 ∈ c ∧ q3 ∈ ch':c.val ≤ a ::ₘ q2 ::ₘ {q3}⊢ a ∈ cinr.mpr.inr.inl𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩q1:𝓩q3:𝓩a:𝓩h:q1 ∈ c ∧ a ∈ c ∧ q3 ∈ ch':c.val ≤ q1 ::ₘ a ::ₘ {q3}⊢ a ∈ cinr.mpr.inr.inr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩q1:𝓩q2:𝓩a:𝓩h:q1 ∈ c ∧ q2 ∈ c ∧ a ∈ ch':c.val ≤ q1 ::ₘ q2 ::ₘ {a}⊢ a ∈ c
      ·inr.mpr.inl𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩q2:𝓩q3:𝓩a:𝓩h:a ∈ c ∧ q2 ∈ c ∧ q3 ∈ ch':c.val ≤ a ::ₘ q2 ::ₘ {q3}⊢ a ∈ c exact h.1All goals completed! 🐙
      ·inr.mpr.inr.inl𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩q1:𝓩q3:𝓩a:𝓩h:q1 ∈ c ∧ a ∈ c ∧ q3 ∈ ch':c.val ≤ q1 ::ₘ a ::ₘ {q3}⊢ a ∈ c exact h.2.1All goals completed! 🐙
      ·inr.mpr.inr.inr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩q1:𝓩q2:𝓩a:𝓩h:q1 ∈ c ∧ q2 ∈ c ∧ a ∈ ch':c.val ≤ q1 ::ₘ q2 ::ₘ {a}⊢ a ∈ c exact h.2.2All goals completed! 🐙

D.3. TenQuanta in `liftCharge c` have no duplicate charges



lemma toCharges_nodup_of_mem_liftCharge (c : Finset 𝓩) {x : TenQuanta 𝓩}
    (h : x ∈ liftCharge c) : x.toCharges.Nodup := by𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x ∈ liftCharge c⊢ x.toCharges.Nodup
  rw [liftCharge,𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x ∈
  Multiset.map reduce
    (Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
      Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map
          (fun x =>
            match x with
            | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
          (c.product (c.product c)).val))⊢ x.toCharges.Nodup𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:∃
  a ∈
    Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
      Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map
          (fun x =>
            match x with
            | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
          (c.product (c.product c)).val),
  a.reduce = x⊢ x.toCharges.Nodup Multiset.mem_map𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:∃
  a ∈
    Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
      Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map
          (fun x =>
            match x with
            | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
          (c.product (c.product c)).val),
  a.reduce = x⊢ x.toCharges.Nodup𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:∃
  a ∈
    Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
      Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map
          (fun x =>
            match x with
            | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
          (c.product (c.product c)).val),
  a.reduce = x⊢ x.toCharges.Nodup] at h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:∃
  a ∈
    Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
      Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map
          (fun x =>
            match x with
            | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
          (c.product (c.product c)).val),
  a.reduce = x⊢ x.toCharges.Nodup
  obtain ⟨x, h, rfl⟩ := h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x ∈
  Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
    Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map
        (fun x =>
          match x with
          | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
        (c.product (c.product c)).val)⊢ x.reduce.toCharges.Nodup
  rw [reduce_toCharges𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x ∈
  Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
    Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map
        (fun x =>
          match x with
          | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
        (c.product (c.product c)).val)⊢ x.toCharges.dedup.Nodup𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x ∈
  Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
    Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map
        (fun x =>
          match x with
          | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
        (c.product (c.product c)).val)⊢ x.toCharges.dedup.Nodup]𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x ∈
  Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
    Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map
        (fun x =>
          match x with
          | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
        (c.product (c.product c)).val)⊢ x.toCharges.dedup.Nodup
  exact Multiset.nodup_dedup x.toChargesAll goals completed! 🐙

D.4. Membership in `liftCharge c` iff is reduction of `TenQuanta` with given fluxes

              

lemma exists_toCharges_toFluxesTen_of_mem_liftCharge (c : Finset 𝓩)
    {x : TenQuanta 𝓩} (h : x ∈ liftCharge c) :
    ∃ a : TenQuanta 𝓩, a.reduce = x ∧ a.toCharges.toFinset = c ∧
    (a.toFluxesTen = {⟨1, 0⟩, ⟨1, 0⟩, ⟨1, 0⟩}
    ∨ a.toFluxesTen = {⟨1, 1⟩, ⟨1, -1⟩, ⟨1, 0⟩}) := by𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x ∈ liftCharge c⊢ ∃ a,
  a.reduce = x ∧
    a.toCharges.toFinset = c ∧
      (a.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
        a.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }})
  have h' := h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x ∈ liftCharge ch':x ∈ liftCharge c⊢ ∃ a,
  a.reduce = x ∧
    a.toCharges.toFinset = c ∧
      (a.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
        a.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }})
  rw [liftCharge,𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x ∈
  Multiset.map reduce
    (Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
      Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map
          (fun x =>
            match x with
            | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
          (c.product (c.product c)).val))h':x ∈ liftCharge c⊢ ∃ a,
  a.reduce = x ∧
    a.toCharges.toFinset = c ∧
      (a.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
        a.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }})𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:∃
  a ∈
    Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
      Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map
          (fun x =>
            match x with
            | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
          (c.product (c.product c)).val),
  a.reduce = xh':x ∈ liftCharge c⊢ ∃ a,
  a.reduce = x ∧
    a.toCharges.toFinset = c ∧
      (a.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
        a.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}) Multiset.mem_map𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:∃
  a ∈
    Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
      Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map
          (fun x =>
            match x with
            | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
          (c.product (c.product c)).val),
  a.reduce = xh':x ∈ liftCharge c⊢ ∃ a,
  a.reduce = x ∧
    a.toCharges.toFinset = c ∧
      (a.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
        a.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }})𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:∃
  a ∈
    Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
      Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map
          (fun x =>
            match x with
            | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
          (c.product (c.product c)).val),
  a.reduce = xh':x ∈ liftCharge c⊢ ∃ a,
  a.reduce = x ∧
    a.toCharges.toFinset = c ∧
      (a.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
        a.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }})] at h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:∃
  a ∈
    Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
      Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map
          (fun x =>
            match x with
            | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
          (c.product (c.product c)).val),
  a.reduce = xh':x ∈ liftCharge c⊢ ∃ a,
  a.reduce = x ∧
    a.toCharges.toFinset = c ∧
      (a.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
        a.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }})
  obtain ⟨a, h, rfl⟩ := h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩a:TenQuanta 𝓩h:a ∈
  Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
    Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map
        (fun x =>
          match x with
          | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
        (c.product (c.product c)).val)h':a.reduce ∈ liftCharge c⊢ ∃ a_1,
  a_1.reduce = a.reduce ∧
    a_1.toCharges.toFinset = c ∧
      (a_1.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
        a_1.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }})
  use ah𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩a:TenQuanta 𝓩h:a ∈
  Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
    Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map
        (fun x =>
          match x with
          | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
        (c.product (c.product c)).val)h':a.reduce ∈ liftCharge c⊢ a.reduce = a.reduce ∧
  a.toCharges.toFinset = c ∧
    (a.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
      a.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }})
  simp only [Multiset.insert_eq_cons, Int.reduceNeg, true_and]h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩a:TenQuanta 𝓩h:a ∈
  Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
    Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map
        (fun x =>
          match x with
          | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
        (c.product (c.product c)).val)h':a.reduce ∈ liftCharge c⊢ a.toCharges.toFinset = c ∧
  (a.toFluxesTen = { M := 1, N := 0 } ::ₘ { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }} ∨
    a.toFluxesTen = { M := 1, N := 1 } ::ₘ { M := 1, N := -1 } ::ₘ {{ M := 1, N := 0 }})
  apply And.introh.left𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩a:TenQuanta 𝓩h:a ∈
  Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
    Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map
        (fun x =>
          match x with
          | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
        (c.product (c.product c)).val)h':a.reduce ∈ liftCharge c⊢ a.toCharges.toFinset = ch.right𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩a:TenQuanta 𝓩h:a ∈
  Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
    Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map
        (fun x =>
          match x with
          | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
        (c.product (c.product c)).val)h':a.reduce ∈ liftCharge c⊢ a.toFluxesTen = { M := 1, N := 0 } ::ₘ { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }} ∨
  a.toFluxesTen = { M := 1, N := 1 } ::ₘ { M := 1, N := -1 } ::ₘ {{ M := 1, N := 0 }}
  ·h.left𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩a:TenQuanta 𝓩h:a ∈
  Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
    Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map
        (fun x =>
          match x with
          | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
        (c.product (c.product c)).val)h':a.reduce ∈ liftCharge c⊢ a.toCharges.toFinset = c rw [← toCharge_toFinset_of_mem_liftCharge c h',h.left𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩a:TenQuanta 𝓩h:a ∈
  Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
    Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map
        (fun x =>
          match x with
          | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
        (c.product (c.product c)).val)h':a.reduce ∈ liftCharge c⊢ a.toCharges.toFinset = a.reduce.toCharges.toFinseth.left𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩a:TenQuanta 𝓩h:a ∈
  Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
    Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map
        (fun x =>
          match x with
          | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
        (c.product (c.product c)).val)h':a.reduce ∈ liftCharge c⊢ a.toCharges.toFinset = a.toCharges.dedup.toFinset reduce_toChargesh.left𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩a:TenQuanta 𝓩h:a ∈
  Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
    Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map
        (fun x =>
          match x with
          | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
        (c.product (c.product c)).val)h':a.reduce ∈ liftCharge c⊢ a.toCharges.toFinset = a.toCharges.dedup.toFinseth.left𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩a:TenQuanta 𝓩h:a ∈
  Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
    Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map
        (fun x =>
          match x with
          | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
        (c.product (c.product c)).val)h':a.reduce ∈ liftCharge c⊢ a.toCharges.toFinset = a.toCharges.dedup.toFinset]h.left𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩a:TenQuanta 𝓩h:a ∈
  Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
    Multiset.filter (fun s => c.val ≤ s.toCharges)
      (Multiset.map
        (fun x =>
          match x with
          | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
        (c.product (c.product c)).val)h':a.reduce ∈ liftCharge c⊢ a.toCharges.toFinset = a.toCharges.dedup.toFinset
    simpAll goals completed! 🐙
  simp at hh.right𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩a:TenQuanta 𝓩h':a.reduce ∈ liftCharge ch:(∃ a_1, (a_1.toFinset ⊆ c ∧ a_1.card = 3) ∧ Multiset.map (fun z => (z, { M := 1, N := 0 })) a_1 = a) ∧
    c.val ≤ a.toCharges ∨
  (∃ a_1 a_2 b,
      (a_1 ∈ c ∧ a_2 ∈ c ∧ b ∈ c) ∧
        (a_1, { M := 1, N := 1 }) ::ₘ (a_2, { M := 1, N := -1 }) ::ₘ {(b, { M := 1, N := 0 })} = a) ∧
    c.val ≤ a.toCharges⊢ a.toFluxesTen = { M := 1, N := 0 } ::ₘ { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }} ∨
  a.toFluxesTen = { M := 1, N := 1 } ::ₘ { M := 1, N := -1 } ::ₘ {{ M := 1, N := 0 }}
  rcases h with h | hh.right.inl𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩a:TenQuanta 𝓩h':a.reduce ∈ liftCharge ch:(∃ a_1, (a_1.toFinset ⊆ c ∧ a_1.card = 3) ∧ Multiset.map (fun z => (z, { M := 1, N := 0 })) a_1 = a) ∧
  c.val ≤ a.toCharges⊢ a.toFluxesTen = { M := 1, N := 0 } ::ₘ { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }} ∨
  a.toFluxesTen = { M := 1, N := 1 } ::ₘ { M := 1, N := -1 } ::ₘ {{ M := 1, N := 0 }}h.right.inr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩a:TenQuanta 𝓩h':a.reduce ∈ liftCharge ch:(∃ a_1 a_2 b,
    (a_1 ∈ c ∧ a_2 ∈ c ∧ b ∈ c) ∧
      (a_1, { M := 1, N := 1 }) ::ₘ (a_2, { M := 1, N := -1 }) ::ₘ {(b, { M := 1, N := 0 })} = a) ∧
  c.val ≤ a.toCharges⊢ a.toFluxesTen = { M := 1, N := 0 } ::ₘ { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }} ∨
  a.toFluxesTen = { M := 1, N := 1 } ::ₘ { M := 1, N := -1 } ::ₘ {{ M := 1, N := 0 }}
  ·h.right.inl𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩a:TenQuanta 𝓩h':a.reduce ∈ liftCharge ch:(∃ a_1, (a_1.toFinset ⊆ c ∧ a_1.card = 3) ∧ Multiset.map (fun z => (z, { M := 1, N := 0 })) a_1 = a) ∧
  c.val ≤ a.toCharges⊢ a.toFluxesTen = { M := 1, N := 0 } ::ₘ { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }} ∨
  a.toFluxesTen = { M := 1, N := 1 } ::ₘ { M := 1, N := -1 } ::ₘ {{ M := 1, N := 0 }} obtain ⟨⟨s, h, rfl⟩, h'⟩ := hh.right.inl𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩s:Multiset 𝓩h:s.toFinset ⊆ c ∧ s.card = 3h'✝:reduce (Multiset.map (fun z => (z, { M := 1, N := 0 })) s) ∈ liftCharge ch':c.val ≤ toCharges (Multiset.map (fun z => (z, { M := 1, N := 0 })) s)⊢ toFluxesTen (Multiset.map (fun z => (z, { M := 1, N := 0 })) s) =
    { M := 1, N := 0 } ::ₘ { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }} ∨
  toFluxesTen (Multiset.map (fun z => (z, { M := 1, N := 0 })) s) =
    { M := 1, N := 1 } ::ₘ { M := 1, N := -1 } ::ₘ {{ M := 1, N := 0 }}
    lefth.right.inl𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩s:Multiset 𝓩h:s.toFinset ⊆ c ∧ s.card = 3h'✝:reduce (Multiset.map (fun z => (z, { M := 1, N := 0 })) s) ∈ liftCharge ch':c.val ≤ toCharges (Multiset.map (fun z => (z, { M := 1, N := 0 })) s)⊢ toFluxesTen (Multiset.map (fun z => (z, { M := 1, N := 0 })) s) =
  { M := 1, N := 0 } ::ₘ { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }}
    simp [toFluxesTen]h.right.inl𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩s:Multiset 𝓩h:s.toFinset ⊆ c ∧ s.card = 3h'✝:reduce (Multiset.map (fun z => (z, { M := 1, N := 0 })) s) ∈ liftCharge ch':c.val ≤ toCharges (Multiset.map (fun z => (z, { M := 1, N := 0 })) s)⊢ Multiset.replicate s.card { M := 1, N := 0 } = { M := 1, N := 0 } ::ₘ { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }}
    rw [h.2h.right.inl𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩s:Multiset 𝓩h:s.toFinset ⊆ c ∧ s.card = 3h'✝:reduce (Multiset.map (fun z => (z, { M := 1, N := 0 })) s) ∈ liftCharge ch':c.val ≤ toCharges (Multiset.map (fun z => (z, { M := 1, N := 0 })) s)⊢ Multiset.replicate 3 { M := 1, N := 0 } = { M := 1, N := 0 } ::ₘ { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }}h.right.inl𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩s:Multiset 𝓩h:s.toFinset ⊆ c ∧ s.card = 3h'✝:reduce (Multiset.map (fun z => (z, { M := 1, N := 0 })) s) ∈ liftCharge ch':c.val ≤ toCharges (Multiset.map (fun z => (z, { M := 1, N := 0 })) s)⊢ Multiset.replicate 3 { M := 1, N := 0 } = { M := 1, N := 0 } ::ₘ { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }}]h.right.inl𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩s:Multiset 𝓩h:s.toFinset ⊆ c ∧ s.card = 3h'✝:reduce (Multiset.map (fun z => (z, { M := 1, N := 0 })) s) ∈ liftCharge ch':c.val ≤ toCharges (Multiset.map (fun z => (z, { M := 1, N := 0 })) s)⊢ Multiset.replicate 3 { M := 1, N := 0 } = { M := 1, N := 0 } ::ₘ { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }}
    decideAll goals completed! 🐙
  ·h.right.inr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩a:TenQuanta 𝓩h':a.reduce ∈ liftCharge ch:(∃ a_1 a_2 b,
    (a_1 ∈ c ∧ a_2 ∈ c ∧ b ∈ c) ∧
      (a_1, { M := 1, N := 1 }) ::ₘ (a_2, { M := 1, N := -1 }) ::ₘ {(b, { M := 1, N := 0 })} = a) ∧
  c.val ≤ a.toCharges⊢ a.toFluxesTen = { M := 1, N := 0 } ::ₘ { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }} ∨
  a.toFluxesTen = { M := 1, N := 1 } ::ₘ { M := 1, N := -1 } ::ₘ {{ M := 1, N := 0 }} obtain ⟨⟨q1, q2, q3, h, rfl⟩, h'⟩ := hh.right.inr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩q1:𝓩q2:𝓩q3:𝓩h:q1 ∈ c ∧ q2 ∈ c ∧ q3 ∈ ch'✝:reduce ((q1, { M := 1, N := 1 }) ::ₘ (q2, { M := 1, N := -1 }) ::ₘ {(q3, { M := 1, N := 0 })}) ∈ liftCharge ch':c.val ≤ toCharges ((q1, { M := 1, N := 1 }) ::ₘ (q2, { M := 1, N := -1 }) ::ₘ {(q3, { M := 1, N := 0 })})⊢ toFluxesTen ((q1, { M := 1, N := 1 }) ::ₘ (q2, { M := 1, N := -1 }) ::ₘ {(q3, { M := 1, N := 0 })}) =
    { M := 1, N := 0 } ::ₘ { M := 1, N := 0 } ::ₘ {{ M := 1, N := 0 }} ∨
  toFluxesTen ((q1, { M := 1, N := 1 }) ::ₘ (q2, { M := 1, N := -1 }) ::ₘ {(q3, { M := 1, N := 0 })}) =
    { M := 1, N := 1 } ::ₘ { M := 1, N := -1 } ::ₘ {{ M := 1, N := 0 }}
    simp [toFluxesTen]All goals completed! 🐙

lemma mem_liftCharge_of_exists_toCharges_toFluxesTen (c : Finset 𝓩) {x : TenQuanta 𝓩}
    (h :∃ a : TenQuanta 𝓩, a.reduce = x ∧ a.toCharges.toFinset = c ∧
    (a.toFluxesTen = {⟨1, 0⟩, ⟨1, 0⟩, ⟨1, 0⟩}
    ∨ a.toFluxesTen = {⟨1, 1⟩, ⟨1, -1⟩, ⟨1, 0⟩})) :
    x ∈ liftCharge c := by𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:∃ a,
  a.reduce = x ∧
    a.toCharges.toFinset = c ∧
      (a.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
        a.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }})⊢ x ∈ liftCharge c
  obtain ⟨x, rfl, h, h2⟩ := h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
  x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}⊢ x.reduce ∈ liftCharge c
  rw [liftCharge,𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
  x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}⊢ x.reduce ∈
  Multiset.map reduce
    (Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
      Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map
          (fun x =>
            match x with
            | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
          (c.product (c.product c)).val))𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
  x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}⊢ ∃
  a ∈
    Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
      Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map
          (fun x =>
            match x with
            | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
          (c.product (c.product c)).val),
  a.reduce = x.reduce Multiset.mem_map𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
  x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}⊢ ∃
  a ∈
    Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
      Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map
          (fun x =>
            match x with
            | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
          (c.product (c.product c)).val),
  a.reduce = x.reduce𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
  x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}⊢ ∃
  a ∈
    Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
      Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map
          (fun x =>
            match x with
            | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
          (c.product (c.product c)).val),
  a.reduce = x.reduce]𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
  x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}⊢ ∃
  a ∈
    Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
      Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map
          (fun x =>
            match x with
            | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
          (c.product (c.product c)).val),
  a.reduce = x.reduce
  use xh𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
  x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}⊢ x ∈
    Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map (fun s => Multiset.map (fun z => (z, { M := 1, N := 0 })) s) (toMultisetsThree c)) +
      Multiset.filter (fun s => c.val ≤ s.toCharges)
        (Multiset.map
          (fun x =>
            match x with
            | (x, y, z) => {(x, { M := 1, N := 1 }), (y, { M := 1, N := -1 }), (z, { M := 1, N := 0 })})
          (c.product (c.product c)).val) ∧
  x.reduce = x.reduce
  simp only [Finset.product_eq_sprod, Finset.product_val, Int.reduceNeg, Multiset.insert_eq_cons,
    Multiset.mem_add, Multiset.mem_filter, Multiset.mem_map, mem_toMultisetsThree_iff, Prod.exists,
    and_true]h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
  x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}⊢ (∃ a, (a.toFinset ⊆ c ∧ a.card = 3) ∧ Multiset.map (fun z => (z, { M := 1, N := 0 })) a = x) ∧ c.val ≤ x.toCharges ∨
  (∃ a a_1 b,
      (a, a_1, b) ∈ c.val ×ˢ c.val ×ˢ c.val ∧
        (a, { M := 1, N := 1 }) ::ₘ (a_1, { M := 1, N := -1 }) ::ₘ {(b, { M := 1, N := 0 })} = x) ∧
    c.val ≤ x.toCharges
  rcases h2 with h2 | h2h.inl𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ (∃ a, (a.toFinset ⊆ c ∧ a.card = 3) ∧ Multiset.map (fun z => (z, { M := 1, N := 0 })) a = x) ∧ c.val ≤ x.toCharges ∨
  (∃ a a_1 b,
      (a, a_1, b) ∈ c.val ×ˢ c.val ×ˢ c.val ∧
        (a, { M := 1, N := 1 }) ::ₘ (a_1, { M := 1, N := -1 }) ::ₘ {(b, { M := 1, N := 0 })} = x) ∧
    c.val ≤ x.toChargesh.inr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}⊢ (∃ a, (a.toFinset ⊆ c ∧ a.card = 3) ∧ Multiset.map (fun z => (z, { M := 1, N := 0 })) a = x) ∧ c.val ≤ x.toCharges ∨
  (∃ a a_1 b,
      (a, a_1, b) ∈ c.val ×ˢ c.val ×ˢ c.val ∧
        (a, { M := 1, N := 1 }) ::ₘ (a_1, { M := 1, N := -1 }) ::ₘ {(b, { M := 1, N := 0 })} = x) ∧
    c.val ≤ x.toCharges
  ·h.inl𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ (∃ a, (a.toFinset ⊆ c ∧ a.card = 3) ∧ Multiset.map (fun z => (z, { M := 1, N := 0 })) a = x) ∧ c.val ≤ x.toCharges ∨
  (∃ a a_1 b,
      (a, a_1, b) ∈ c.val ×ˢ c.val ×ˢ c.val ∧
        (a, { M := 1, N := 1 }) ::ₘ (a_1, { M := 1, N := -1 }) ::ₘ {(b, { M := 1, N := 0 })} = x) ∧
    c.val ≤ x.toCharges lefth.inl𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ (∃ a, (a.toFinset ⊆ c ∧ a.card = 3) ∧ Multiset.map (fun z => (z, { M := 1, N := 0 })) a = x) ∧ c.val ≤ x.toCharges
    subst hh.inl𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ (∃ a, (a.toFinset ⊆ x.toCharges.toFinset ∧ a.card = 3) ∧ Multiset.map (fun z => (z, { M := 1, N := 0 })) a = x) ∧
  x.toCharges.toFinset.val ≤ x.toCharges
    simp only [Multiset.toFinset_subset, Multiset.toFinset_val]h.inl𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ (∃ a, (a ⊆ x.toCharges ∧ a.card = 3) ∧ Multiset.map (fun z => (z, { M := 1, N := 0 })) a = x) ∧
  x.toCharges.dedup ≤ x.toCharges
    apply And.introh.inl.left𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ ∃ a, (a ⊆ x.toCharges ∧ a.card = 3) ∧ Multiset.map (fun z => (z, { M := 1, N := 0 })) a = xh.inl.right𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ x.toCharges.dedup ≤ x.toCharges
    ·h.inl.left𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ ∃ a, (a ⊆ x.toCharges ∧ a.card = 3) ∧ Multiset.map (fun z => (z, { M := 1, N := 0 })) a = x use x.toChargesh𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ (x.toCharges ⊆ x.toCharges ∧ x.toCharges.card = 3) ∧ Multiset.map (fun z => (z, { M := 1, N := 0 })) x.toCharges = x
      simp only [Multiset.Subset.refl, true_and]h𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ x.toCharges.card = 3 ∧ Multiset.map (fun z => (z, { M := 1, N := 0 })) x.toCharges = x
      apply And.introh.left𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ x.toCharges.card = 3h.right𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ Multiset.map (fun z => (z, { M := 1, N := 0 })) x.toCharges = x
      ·h.left𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ x.toCharges.card = 3 simp [toCharges]h.left𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ Multiset.card x = 3
        trans x.toFluxesTen.card𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ Multiset.card x = Multiset.card x.toFluxesTen𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ Multiset.card x.toFluxesTen = 3
        ·𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ Multiset.card x = Multiset.card x.toFluxesTen simp [toFluxesTen]All goals completed! 🐙
        rw [h2𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ Multiset.card {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} = 3𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ Multiset.card {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} = 3]𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ Multiset.card {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} = 3
        decideAll goals completed! 🐙
      ·h.right𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ Multiset.map (fun z => (z, { M := 1, N := 0 })) x.toCharges = x trans Multiset.map (fun z => z) x𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ Multiset.map (fun z => (z, { M := 1, N := 0 })) x.toCharges = Multiset.map (fun z => z) x𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ Multiset.map (fun z => z) x = x
        swap𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ Multiset.map (fun z => z) x = x𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ Multiset.map (fun z => (z, { M := 1, N := 0 })) x.toCharges = Multiset.map (fun z => z) x
        ·𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ Multiset.map (fun z => z) x = x simpAll goals completed! 🐙
        rw [toCharges,𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ Multiset.map (fun z => (z, { M := 1, N := 0 })) (Multiset.map Prod.fst x) = Multiset.map (fun z => z) x𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ Multiset.map ((fun z => (z, { M := 1, N := 0 })) ∘ Prod.fst) x = Multiset.map (fun z => z) x Multiset.map_map𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ Multiset.map ((fun z => (z, { M := 1, N := 0 })) ∘ Prod.fst) x = Multiset.map (fun z => z) x𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ Multiset.map ((fun z => (z, { M := 1, N := 0 })) ∘ Prod.fst) x = Multiset.map (fun z => z) x]𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ Multiset.map ((fun z => (z, { M := 1, N := 0 })) ∘ Prod.fst) x = Multiset.map (fun z => z) x
        refine Multiset.map_congr rfl fun p hp => ?_𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}p:𝓩 × Fluxeshp:p ∈ x⊢ ((fun z => (z, { M := 1, N := 0 })) ∘ Prod.fst) p = p
        simp only [Function.comp_apply]𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}p:𝓩 × Fluxeshp:p ∈ x⊢ (p.1, { M := 1, N := 0 }) = p
        have h1 : p.2 ∈ x.toFluxesTen := by𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:∃ a,
  a.reduce = x ∧
    a.toCharges.toFinset = c ∧
      (a.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
        a.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }})⊢ x ∈ liftCharge c𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}p:𝓩 × Fluxeshp:p ∈ xh1:p.2 ∈ x.toFluxesTen⊢ (p.1, { M := 1, N := 0 }) = p
          simp [toFluxesTen]𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}p:𝓩 × Fluxeshp:p ∈ x⊢ ∃ a, (a, p.2) ∈ x𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}p:𝓩 × Fluxeshp:p ∈ xh1:p.2 ∈ x.toFluxesTen⊢ (p.1, { M := 1, N := 0 }) = p
          use p.1𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}p:𝓩 × Fluxeshp:p ∈ xh1:p.2 ∈ x.toFluxesTen⊢ (p.1, { M := 1, N := 0 }) = p𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}p:𝓩 × Fluxeshp:p ∈ xh1:p.2 ∈ x.toFluxesTen⊢ (p.1, { M := 1, N := 0 }) = p
        rw [h2𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}p:𝓩 × Fluxeshp:p ∈ xh1:p.2 ∈ {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ (p.1, { M := 1, N := 0 }) = p𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}p:𝓩 × Fluxeshp:p ∈ xh1:p.2 ∈ {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ (p.1, { M := 1, N := 0 }) = p] at h1𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}p:𝓩 × Fluxeshp:p ∈ xh1:p.2 ∈ {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ (p.1, { M := 1, N := 0 }) = p
        simp at h1𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}p:𝓩 × Fluxeshp:p ∈ xh1:p.2 = { M := 1, N := 0 }⊢ (p.1, { M := 1, N := 0 }) = p
        change _ = (p.1, p.2)𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}p:𝓩 × Fluxeshp:p ∈ xh1:p.2 = { M := 1, N := 0 }⊢ (p.1, { M := 1, N := 0 }) = (p.1, p.2)
        rw [h1𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}p:𝓩 × Fluxeshp:p ∈ xh1:p.2 = { M := 1, N := 0 }⊢ (p.1, { M := 1, N := 0 }) = (p.1, { M := 1, N := 0 })All goals completed! 🐙]All goals completed! 🐙
    ·h.inl.right𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ x.toCharges.dedup ≤ x.toCharges exact Multiset.dedup_le x.toChargesAll goals completed! 🐙
  ·h.inr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}⊢ (∃ a, (a.toFinset ⊆ c ∧ a.card = 3) ∧ Multiset.map (fun z => (z, { M := 1, N := 0 })) a = x) ∧ c.val ≤ x.toCharges ∨
  (∃ a a_1 b,
      (a, a_1, b) ∈ c.val ×ˢ c.val ×ˢ c.val ∧
        (a, { M := 1, N := 1 }) ::ₘ (a_1, { M := 1, N := -1 }) ::ₘ {(b, { M := 1, N := 0 })} = x) ∧
    c.val ≤ x.toCharges righth.inr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}⊢ (∃ a a_1 b,
    (a, a_1, b) ∈ c.val ×ˢ c.val ×ˢ c.val ∧
      (a, { M := 1, N := 1 }) ::ₘ (a_1, { M := 1, N := -1 }) ::ₘ {(b, { M := 1, N := 0 })} = x) ∧
  c.val ≤ x.toCharges
    have h2' := h2h.inr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}⊢ (∃ a a_1 b,
    (a, a_1, b) ∈ c.val ×ˢ c.val ×ˢ c.val ∧
      (a, { M := 1, N := 1 }) ::ₘ (a_1, { M := 1, N := -1 }) ::ₘ {(b, { M := 1, N := 0 })} = x) ∧
  c.val ≤ x.toCharges
    simp [toFluxesTen] at h2h.inr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x.toCharges.toFinset = ch2:Multiset.map Prod.snd x = { M := 1, N := 1 } ::ₘ { M := 1, N := -1 } ::ₘ {{ M := 1, N := 0 }}h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}⊢ (∃ a a_1 b,
    (a, a_1, b) ∈ c.val ×ˢ c.val ×ˢ c.val ∧
      (a, { M := 1, N := 1 }) ::ₘ (a_1, { M := 1, N := -1 }) ::ₘ {(b, { M := 1, N := 0 })} = x) ∧
  c.val ≤ x.toCharges
    rw [← Multiset.map_eq_consh.inr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x.toCharges.toFinset = ch2:∃ a ∈ x,
  a.2 = { M := 1, N := 1 } ∧ Multiset.map Prod.snd (Multiset.erase x a) = { M := 1, N := -1 } ::ₘ {{ M := 1, N := 0 }}h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}⊢ (∃ a a_1 b,
    (a, a_1, b) ∈ c.val ×ˢ c.val ×ˢ c.val ∧
      (a, { M := 1, N := 1 }) ::ₘ (a_1, { M := 1, N := -1 }) ::ₘ {(b, { M := 1, N := 0 })} = x) ∧
  c.val ≤ x.toChargesh.inr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x.toCharges.toFinset = ch2:∃ a ∈ x,
  a.2 = { M := 1, N := 1 } ∧ Multiset.map Prod.snd (Multiset.erase x a) = { M := 1, N := -1 } ::ₘ {{ M := 1, N := 0 }}h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}⊢ (∃ a a_1 b,
    (a, a_1, b) ∈ c.val ×ˢ c.val ×ˢ c.val ∧
      (a, { M := 1, N := 1 }) ::ₘ (a_1, { M := 1, N := -1 }) ::ₘ {(b, { M := 1, N := 0 })} = x) ∧
  c.val ≤ x.toCharges] at h2h.inr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x.toCharges.toFinset = ch2:∃ a ∈ x,
  a.2 = { M := 1, N := 1 } ∧ Multiset.map Prod.snd (Multiset.erase x a) = { M := 1, N := -1 } ::ₘ {{ M := 1, N := 0 }}h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}⊢ (∃ a a_1 b,
    (a, a_1, b) ∈ c.val ×ˢ c.val ×ˢ c.val ∧
      (a, { M := 1, N := 1 }) ::ₘ (a_1, { M := 1, N := -1 }) ::ₘ {(b, { M := 1, N := 0 })} = x) ∧
  c.val ≤ x.toCharges
    obtain ⟨p1, hp1, hp1_2, h2⟩ := h2h.inr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x.toCharges.toFinset = ch2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }h2:Multiset.map Prod.snd (Multiset.erase x p1) = { M := 1, N := -1 } ::ₘ {{ M := 1, N := 0 }}⊢ (∃ a a_1 b,
    (a, a_1, b) ∈ c.val ×ˢ c.val ×ˢ c.val ∧
      (a, { M := 1, N := 1 }) ::ₘ (a_1, { M := 1, N := -1 }) ::ₘ {(b, { M := 1, N := 0 })} = x) ∧
  c.val ≤ x.toCharges
    rw [← Multiset.map_eq_consh.inr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x.toCharges.toFinset = ch2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }h2:∃ a ∈ Multiset.erase x p1,
  a.2 = { M := 1, N := -1 } ∧ Multiset.map Prod.snd ((Multiset.erase x p1).erase a) = {{ M := 1, N := 0 }}⊢ (∃ a a_1 b,
    (a, a_1, b) ∈ c.val ×ˢ c.val ×ˢ c.val ∧
      (a, { M := 1, N := 1 }) ::ₘ (a_1, { M := 1, N := -1 }) ::ₘ {(b, { M := 1, N := 0 })} = x) ∧
  c.val ≤ x.toChargesh.inr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x.toCharges.toFinset = ch2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }h2:∃ a ∈ Multiset.erase x p1,
  a.2 = { M := 1, N := -1 } ∧ Multiset.map Prod.snd ((Multiset.erase x p1).erase a) = {{ M := 1, N := 0 }}⊢ (∃ a a_1 b,
    (a, a_1, b) ∈ c.val ×ˢ c.val ×ˢ c.val ∧
      (a, { M := 1, N := 1 }) ::ₘ (a_1, { M := 1, N := -1 }) ::ₘ {(b, { M := 1, N := 0 })} = x) ∧
  c.val ≤ x.toCharges] at h2h.inr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x.toCharges.toFinset = ch2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }h2:∃ a ∈ Multiset.erase x p1,
  a.2 = { M := 1, N := -1 } ∧ Multiset.map Prod.snd ((Multiset.erase x p1).erase a) = {{ M := 1, N := 0 }}⊢ (∃ a a_1 b,
    (a, a_1, b) ∈ c.val ×ˢ c.val ×ˢ c.val ∧
      (a, { M := 1, N := 1 }) ::ₘ (a_1, { M := 1, N := -1 }) ::ₘ {(b, { M := 1, N := 0 })} = x) ∧
  c.val ≤ x.toCharges
    obtain ⟨p2, hp2, hp2_2, h2⟩ := h2h.inr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x.toCharges.toFinset = ch2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }h2:Multiset.map Prod.snd ((Multiset.erase x p1).erase p2) = {{ M := 1, N := 0 }}⊢ (∃ a a_1 b,
    (a, a_1, b) ∈ c.val ×ˢ c.val ×ˢ c.val ∧
      (a, { M := 1, N := 1 }) ::ₘ (a_1, { M := 1, N := -1 }) ::ₘ {(b, { M := 1, N := 0 })} = x) ∧
  c.val ≤ x.toCharges
    rw [Multiset.map_eq_singletonh.inr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x.toCharges.toFinset = ch2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }h2:∃ a, (Multiset.erase x p1).erase p2 = {a} ∧ a.2 = { M := 1, N := 0 }⊢ (∃ a a_1 b,
    (a, a_1, b) ∈ c.val ×ˢ c.val ×ˢ c.val ∧
      (a, { M := 1, N := 1 }) ::ₘ (a_1, { M := 1, N := -1 }) ::ₘ {(b, { M := 1, N := 0 })} = x) ∧
  c.val ≤ x.toChargesh.inr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x.toCharges.toFinset = ch2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }h2:∃ a, (Multiset.erase x p1).erase p2 = {a} ∧ a.2 = { M := 1, N := 0 }⊢ (∃ a a_1 b,
    (a, a_1, b) ∈ c.val ×ˢ c.val ×ˢ c.val ∧
      (a, { M := 1, N := 1 }) ::ₘ (a_1, { M := 1, N := -1 }) ::ₘ {(b, { M := 1, N := 0 })} = x) ∧
  c.val ≤ x.toCharges] at h2h.inr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x.toCharges.toFinset = ch2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }h2:∃ a, (Multiset.erase x p1).erase p2 = {a} ∧ a.2 = { M := 1, N := 0 }⊢ (∃ a a_1 b,
    (a, a_1, b) ∈ c.val ×ˢ c.val ×ˢ c.val ∧
      (a, { M := 1, N := 1 }) ::ₘ (a_1, { M := 1, N := -1 }) ::ₘ {(b, { M := 1, N := 0 })} = x) ∧
  c.val ≤ x.toCharges
    obtain ⟨p3, hp3, hp3_2⟩ := h2h.inr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x.toCharges.toFinset = ch2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (∃ a a_1 b,
    (a, a_1, b) ∈ c.val ×ˢ c.val ×ˢ c.val ∧
      (a, { M := 1, N := 1 }) ::ₘ (a_1, { M := 1, N := -1 }) ::ₘ {(b, { M := 1, N := 0 })} = x) ∧
  c.val ≤ x.toCharges
    apply And.introh.inr.left𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x.toCharges.toFinset = ch2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ ∃ a a_1 b,
  (a, a_1, b) ∈ c.val ×ˢ c.val ×ˢ c.val ∧
    (a, { M := 1, N := 1 }) ::ₘ (a_1, { M := 1, N := -1 }) ::ₘ {(b, { M := 1, N := 0 })} = xh.inr.right𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x.toCharges.toFinset = ch2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ c.val ≤ x.toCharges
    ·h.inr.left𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x.toCharges.toFinset = ch2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ ∃ a a_1 b,
  (a, a_1, b) ∈ c.val ×ˢ c.val ×ˢ c.val ∧
    (a, { M := 1, N := 1 }) ::ₘ (a_1, { M := 1, N := -1 }) ::ₘ {(b, { M := 1, N := 0 })} = x use p1.1, p2.1, p3.1h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x.toCharges.toFinset = ch2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p1.1, p2.1, p3.1) ∈ c.val ×ˢ c.val ×ˢ c.val ∧
  (p1.1, { M := 1, N := 1 }) ::ₘ (p2.1, { M := 1, N := -1 }) ::ₘ {(p3.1, { M := 1, N := 0 })} = x
      subst hh𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p1.1, p2.1, p3.1) ∈ x.toCharges.toFinset.val ×ˢ x.toCharges.toFinset.val ×ˢ x.toCharges.toFinset.val ∧
  (p1.1, { M := 1, N := 1 }) ::ₘ (p2.1, { M := 1, N := -1 }) ::ₘ {(p3.1, { M := 1, N := 0 })} = x
      simp only [Multiset.toFinset_val, Multiset.mem_product, Multiset.mem_dedup, Int.reduceNeg]h𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p1.1 ∈ x.toCharges ∧ p2.1 ∈ x.toCharges ∧ p3.1 ∈ x.toCharges) ∧
  (p1.1, { M := 1, N := 1 }) ::ₘ (p2.1, { M := 1, N := -1 }) ::ₘ {(p3.1, { M := 1, N := 0 })} = x
      refine ⟨⟨?_, ?_, ?_⟩, ?_⟩h.refine_1𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ p1.1 ∈ x.toChargesh.refine_2𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ p2.1 ∈ x.toChargesh.refine_3𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ p3.1 ∈ x.toChargesh.refine_4𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p1.1, { M := 1, N := 1 }) ::ₘ (p2.1, { M := 1, N := -1 }) ::ₘ {(p3.1, { M := 1, N := 0 })} = x
      ·h.refine_1𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ p1.1 ∈ x.toCharges simp [toCharges]h.refine_1𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ ∃ x_1, (p1.1, x_1) ∈ x
        use p1.2All goals completed! 🐙
      ·h.refine_2𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ p2.1 ∈ x.toCharges simp [toCharges]h.refine_2𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ ∃ x_1, (p2.1, x_1) ∈ x
        use p2.2h𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p2.1, p2.2) ∈ x
        apply Multiset.erase_subset p1 x hp2All goals completed! 🐙
      ·h.refine_3𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ p3.1 ∈ x.toCharges simp [toCharges]h.refine_3𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ ∃ x_1, (p3.1, x_1) ∈ x
        use p3.2h𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p3.1, p3.2) ∈ x
        apply Multiset.erase_subset p1 xh𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p3.1, p3.2) ∈ Multiset.erase x p1
        apply Multiset.erase_subset p2 _h𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p3.1, p3.2) ∈ (Multiset.erase x p1).erase p2
        rw [hp3h𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p3.1, p3.2) ∈ {p3}h𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p3.1, p3.2) ∈ {p3}]h𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p3.1, p3.2) ∈ {p3}
        simpAll goals completed! 🐙
      ·h.refine_4𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p1.1, { M := 1, N := 1 }) ::ₘ (p2.1, { M := 1, N := -1 }) ::ₘ {(p3.1, { M := 1, N := 0 })} = x refine Multiset.eq_of_le_of_card_le ?_ ?_h.refine_4.refine_1𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p1.1, { M := 1, N := 1 }) ::ₘ (p2.1, { M := 1, N := -1 }) ::ₘ {(p3.1, { M := 1, N := 0 })} ≤ xh.refine_4.refine_2𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ Multiset.card x ≤ ((p1.1, { M := 1, N := 1 }) ::ₘ (p2.1, { M := 1, N := -1 }) ::ₘ {(p3.1, { M := 1, N := 0 })}).card
        ·h.refine_4.refine_1𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p1.1, { M := 1, N := 1 }) ::ₘ (p2.1, { M := 1, N := -1 }) ::ₘ {(p3.1, { M := 1, N := 0 })} ≤ x refine (Multiset.cons_le_of_notMem ?_).mpr ⟨?_, ?_⟩h.refine_4.refine_1.refine_1𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p1.1, { M := 1, N := 1 }) ∉ (p2.1, { M := 1, N := -1 }) ::ₘ {(p3.1, { M := 1, N := 0 })}h.refine_4.refine_1.refine_2𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p1.1, { M := 1, N := 1 }) ∈ xh.refine_4.refine_1.refine_3𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p2.1, { M := 1, N := -1 }) ::ₘ {(p3.1, { M := 1, N := 0 })} ≤ x
          ·h.refine_4.refine_1.refine_1𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p1.1, { M := 1, N := 1 }) ∉ (p2.1, { M := 1, N := -1 }) ::ₘ {(p3.1, { M := 1, N := 0 })} simpAll goals completed! 🐙
          ·h.refine_4.refine_1.refine_2𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p1.1, { M := 1, N := 1 }) ∈ x rw [← hp1_2h.refine_4.refine_1.refine_2𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p1.1, p1.2) ∈ xh.refine_4.refine_1.refine_2𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p1.1, p1.2) ∈ x]h.refine_4.refine_1.refine_2𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p1.1, p1.2) ∈ x
            exact hp1All goals completed! 🐙
          refine (Multiset.cons_le_of_notMem ?_).mpr ⟨?_, ?_⟩h.refine_4.refine_1.refine_3.refine_1𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p2.1, { M := 1, N := -1 }) ∉ {(p3.1, { M := 1, N := 0 })}h.refine_4.refine_1.refine_3.refine_2𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p2.1, { M := 1, N := -1 }) ∈ xh.refine_4.refine_1.refine_3.refine_3𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ {(p3.1, { M := 1, N := 0 })} ≤ x
          ·h.refine_4.refine_1.refine_3.refine_1𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p2.1, { M := 1, N := -1 }) ∉ {(p3.1, { M := 1, N := 0 })} simpAll goals completed! 🐙
          ·h.refine_4.refine_1.refine_3.refine_2𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p2.1, { M := 1, N := -1 }) ∈ x rw [← hp2_2h.refine_4.refine_1.refine_3.refine_2𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p2.1, p2.2) ∈ xh.refine_4.refine_1.refine_3.refine_2𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p2.1, p2.2) ∈ x]h.refine_4.refine_1.refine_3.refine_2𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p2.1, p2.2) ∈ x
            apply Multiset.erase_subset p1 xh.refine_4.refine_1.refine_3.refine_2𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p2.1, p2.2) ∈ Multiset.erase x p1
            exact hp2All goals completed! 🐙
          simp only [Multiset.singleton_le]h.refine_4.refine_1.refine_3.refine_3𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p3.1, { M := 1, N := 0 }) ∈ x
          rw [← hp3_2h.refine_4.refine_1.refine_3.refine_3𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p3.1, p3.2) ∈ xh.refine_4.refine_1.refine_3.refine_3𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p3.1, p3.2) ∈ x]h.refine_4.refine_1.refine_3.refine_3𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p3.1, p3.2) ∈ x
          apply Multiset.erase_subset p1 xh.refine_4.refine_1.refine_3.refine_3𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p3.1, p3.2) ∈ Multiset.erase x p1
          apply Multiset.erase_subset p2 _h.refine_4.refine_1.refine_3.refine_3𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p3.1, p3.2) ∈ (Multiset.erase x p1).erase p2
          rw [hp3h.refine_4.refine_1.refine_3.refine_3𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p3.1, p3.2) ∈ {p3}h.refine_4.refine_1.refine_3.refine_3𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p3.1, p3.2) ∈ {p3}]h.refine_4.refine_1.refine_3.refine_3𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ (p3.1, p3.2) ∈ {p3}
          simpAll goals completed! 🐙
        ·h.refine_4.refine_2𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ Multiset.card x ≤ ((p1.1, { M := 1, N := 1 }) ::ₘ (p2.1, { M := 1, N := -1 }) ::ₘ {(p3.1, { M := 1, N := 0 })}).card trans x.toFluxesTen.card𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ Multiset.card x ≤ Multiset.card x.toFluxesTen𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ Multiset.card x.toFluxesTen ≤
  ((p1.1, { M := 1, N := 1 }) ::ₘ (p2.1, { M := 1, N := -1 }) ::ₘ {(p3.1, { M := 1, N := 0 })}).card
          ·𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ Multiset.card x ≤ Multiset.card x.toFluxesTen simp [toFluxesTen]All goals completed! 🐙
          rw [h2'𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ Multiset.card {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }} ≤
  ((p1.1, { M := 1, N := 1 }) ::ₘ (p2.1, { M := 1, N := -1 }) ::ₘ {(p3.1, { M := 1, N := 0 })}).card𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ Multiset.card {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }} ≤
  ((p1.1, { M := 1, N := 1 }) ::ₘ (p2.1, { M := 1, N := -1 }) ::ₘ {(p3.1, { M := 1, N := 0 })}).card]𝓩:Typeinst✝:DecidableEq 𝓩x:TenQuanta 𝓩h2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ Multiset.card {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }} ≤
  ((p1.1, { M := 1, N := 1 }) ::ₘ (p2.1, { M := 1, N := -1 }) ::ₘ {(p3.1, { M := 1, N := 0 })}).card
          simpAll goals completed! 🐙
    ·h.inr.right𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x.toCharges.toFinset = ch2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ c.val ≤ x.toCharges rw [← hh.inr.right𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x.toCharges.toFinset = ch2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ x.toCharges.toFinset.val ≤ x.toChargesh.inr.right𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x.toCharges.toFinset = ch2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ x.toCharges.toFinset.val ≤ x.toCharges]h.inr.right𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x.toCharges.toFinset = ch2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ x.toCharges.toFinset.val ≤ x.toCharges
      simp only [Multiset.toFinset_val]h.inr.right𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x.toCharges.toFinset = ch2':x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}p1:𝓩 × Fluxeshp1:p1 ∈ xhp1_2:p1.2 = { M := 1, N := 1 }p2:𝓩 × Fluxeshp2:p2 ∈ Multiset.erase x p1hp2_2:p2.2 = { M := 1, N := -1 }p3:𝓩 × Fluxeshp3:(Multiset.erase x p1).erase p2 = {p3}hp3_2:p3.2 = { M := 1, N := 0 }⊢ x.toCharges.dedup ≤ x.toCharges
      exact Multiset.dedup_le x.toChargesAll goals completed! 🐙lemma mem_liftCharge_iff_exists (c : Finset 𝓩) {x : TenQuanta 𝓩} :
    x ∈ liftCharge c ↔
    ∃ a : TenQuanta 𝓩, a.reduce = x ∧ a.toCharges.toFinset = c ∧
    (a.toFluxesTen = {⟨1, 0⟩, ⟨1, 0⟩, ⟨1, 0⟩}
    ∨ a.toFluxesTen = {⟨1, 1⟩, ⟨1, -1⟩, ⟨1, 0⟩}) := by𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩⊢ x ∈ liftCharge c ↔
  ∃ a,
    a.reduce = x ∧
      a.toCharges.toFinset = c ∧
        (a.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
          a.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }})
  constructormp𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩⊢ x ∈ liftCharge c →
  ∃ a,
    a.reduce = x ∧
      a.toCharges.toFinset = c ∧
        (a.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
          a.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }})mpr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩⊢ (∃ a,
    a.reduce = x ∧
      a.toCharges.toFinset = c ∧
        (a.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
          a.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }})) →
  x ∈ liftCharge c
  ·mp𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩⊢ x ∈ liftCharge c →
  ∃ a,
    a.reduce = x ∧
      a.toCharges.toFinset = c ∧
        (a.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
          a.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}) exact exists_toCharges_toFluxesTen_of_mem_liftCharge cAll goals completed! 🐙
  ·mpr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩⊢ (∃ a,
    a.reduce = x ∧
      a.toCharges.toFinset = c ∧
        (a.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
          a.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }})) →
  x ∈ liftCharge c exact mem_liftCharge_of_exists_toCharges_toFluxesTen cAll goals completed! 🐙

D.5. TenQuanta in `liftCharge c` do not have zero fluxes



lemma hasNoZero_of_mem_liftCharge (c : Finset 𝓩) {x : TenQuanta 𝓩}
    (h : x ∈ liftCharge c) : x.toFluxesTen.HasNoZero := by𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x ∈ liftCharge c⊢ x.toFluxesTen.HasNoZero
  rw [mem_liftCharge_iff_exists𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:∃ a,
  a.reduce = x ∧
    a.toCharges.toFinset = c ∧
      (a.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
        a.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }})⊢ x.toFluxesTen.HasNoZero𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:∃ a,
  a.reduce = x ∧
    a.toCharges.toFinset = c ∧
      (a.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
        a.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }})⊢ x.toFluxesTen.HasNoZero] at h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:∃ a,
  a.reduce = x ∧
    a.toCharges.toFinset = c ∧
      (a.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
        a.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }})⊢ x.toFluxesTen.HasNoZero
  obtain ⟨x, rfl, h1, h2⟩ := h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toCharges.toFinset = ch2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
  x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}⊢ x.reduce.toFluxesTen.HasNoZero
  intro hf𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toCharges.toFinset = ch2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
  x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}hf:0 ∈ x.reduce.toFluxesTen⊢ False
  have hx := mem_powerset_sum_of_mem_reduce_toFluxesTen_filter hf𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toCharges.toFinset = ch2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
  x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}hf:0 ∈ x.reduce.toFluxesTenhx:0 ∈ Multiset.map (fun s => s.sum) (Multiset.filter (fun s => s ≠ 0) (Multiset.powerset x.toFluxesTen))⊢ False
  rcases h2 with h2 | h2inl𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toCharges.toFinset = chf:0 ∈ x.reduce.toFluxesTenhx:0 ∈ Multiset.map (fun s => s.sum) (Multiset.filter (fun s => s ≠ 0) (Multiset.powerset x.toFluxesTen))h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ Falseinr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toCharges.toFinset = chf:0 ∈ x.reduce.toFluxesTenhx:0 ∈ Multiset.map (fun s => s.sum) (Multiset.filter (fun s => s ≠ 0) (Multiset.powerset x.toFluxesTen))h2:x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}⊢ False
  all_goals
    rw [h2inl𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toCharges.toFinset = chf:0 ∈ x.reduce.toFluxesTenhx:0 ∈
  Multiset.map (fun s => s.sum)
    (Multiset.filter (fun s => s ≠ 0) (Multiset.powerset {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}))h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ Falseinr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toCharges.toFinset = chf:0 ∈ x.reduce.toFluxesTenhx:0 ∈
  Multiset.map (fun s => s.sum)
    (Multiset.filter (fun s => s ≠ 0) (Multiset.powerset {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}))h2:x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}⊢ False]inl𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toCharges.toFinset = chf:0 ∈ x.reduce.toFluxesTenhx:0 ∈
  Multiset.map (fun s => s.sum)
    (Multiset.filter (fun s => s ≠ 0) (Multiset.powerset {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}))h2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ Falseinr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toCharges.toFinset = chf:0 ∈ x.reduce.toFluxesTenhx:0 ∈
  Multiset.map (fun s => s.sum)
    (Multiset.filter (fun s => s ≠ 0) (Multiset.powerset {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}))h2:x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}⊢ False at hxinr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toCharges.toFinset = chf:0 ∈ x.reduce.toFluxesTenhx:0 ∈
  Multiset.map (fun s => s.sum)
    (Multiset.filter (fun s => s ≠ 0) (Multiset.powerset {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}))h2:x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}⊢ False
    revert hxinr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toCharges.toFinset = chf:0 ∈ x.reduce.toFluxesTenh2:x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}⊢ 0 ∈
    Multiset.map (fun s => s.sum)
      (Multiset.filter (fun s => s ≠ 0)
        (Multiset.powerset {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }})) →
  False
    decideAll goals completed! 🐙

D.6. TenQuanta in `liftCharge c` have no exotics



lemma noExotics_of_mem_liftCharge (c : Finset 𝓩) (F : TenQuanta 𝓩)
    (h : F ∈ liftCharge c) :
    F.toFluxesTen.NoExotics := by𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩F:TenQuanta 𝓩h:F ∈ liftCharge c⊢ F.toFluxesTen.NoExotics
  rw [mem_liftCharge_iff_exists𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩F:TenQuanta 𝓩h:∃ a,
  a.reduce = F ∧
    a.toCharges.toFinset = c ∧
      (a.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
        a.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }})⊢ F.toFluxesTen.NoExotics𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩F:TenQuanta 𝓩h:∃ a,
  a.reduce = F ∧
    a.toCharges.toFinset = c ∧
      (a.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
        a.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }})⊢ F.toFluxesTen.NoExotics] at h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩F:TenQuanta 𝓩h:∃ a,
  a.reduce = F ∧
    a.toCharges.toFinset = c ∧
      (a.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
        a.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }})⊢ F.toFluxesTen.NoExotics
  obtain ⟨x, rfl, h1, h2⟩ := h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toCharges.toFinset = ch2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
  x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}⊢ x.reduce.toFluxesTen.NoExotics
  apply reduce_noExotics_of_mem_elemsNoExotics𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toCharges.toFinset = ch2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
  x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}⊢ x.toFluxesTen ∈ FluxesTen.elemsNoExotics
  rcases h2 with h2 | h2inl𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toCharges.toFinset = ch2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ x.toFluxesTen ∈ FluxesTen.elemsNoExoticsinr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toCharges.toFinset = ch2:x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}⊢ x.toFluxesTen ∈ FluxesTen.elemsNoExotics
  all_goals
    rw [h2inl𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toCharges.toFinset = ch2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∈ FluxesTen.elemsNoExoticsinr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toCharges.toFinset = ch2:x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}⊢ {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }} ∈ FluxesTen.elemsNoExotics]inl𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toCharges.toFinset = ch2:x.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }}⊢ {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∈ FluxesTen.elemsNoExoticsinr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toCharges.toFinset = ch2:x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}⊢ {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }} ∈ FluxesTen.elemsNoExoticsinr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toCharges.toFinset = ch2:x.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}⊢ {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }} ∈ FluxesTen.elemsNoExotics
    decideAll goals completed! 🐙

D.7. Membership in `liftCharge c` iff have no exotics, no zero fluxes, and charges `c`



lemma mem_liftCharge_of_mem_noExotics_hasNoZero (c : Finset 𝓩) {x : TenQuanta 𝓩}
    (h1 : x.toFluxesTen.NoExotics) (h2 : x.toFluxesTen.HasNoZero)
    (h3 : x.toCharges.toFinset = c) (h4 : x.toCharges.Nodup) :
    x ∈ liftCharge c := by𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toFluxesTen.NoExoticsh2:x.toFluxesTen.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Nodup⊢ x ∈ liftCharge c
  have hf : x.toFluxesTen ∈ FluxesTen.elemsNoExotics := by
    rw [← FluxesTen.noExotics_iff_mem_elemsNoExotics𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toFluxesTen.NoExoticsh2:x.toFluxesTen.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Nodup⊢ x.toFluxesTen.NoExotics ∧ x.toFluxesTen.HasNoZero𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toFluxesTen.NoExoticsh2:x.toFluxesTen.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Nodup⊢ x.toFluxesTen.NoExotics ∧ x.toFluxesTen.HasNoZero𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toFluxesTen.NoExoticsh2:x.toFluxesTen.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ x ∈ liftCharge c]𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toFluxesTen.NoExoticsh2:x.toFluxesTen.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Nodup⊢ x.toFluxesTen.NoExotics ∧ x.toFluxesTen.HasNoZero𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toFluxesTen.NoExoticsh2:x.toFluxesTen.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ x ∈ liftCharge c
    exact ⟨h1, h2⟩𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toFluxesTen.NoExoticsh2:x.toFluxesTen.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ x ∈ liftCharge c𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toFluxesTen.NoExoticsh2:x.toFluxesTen.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ x ∈ liftCharge c
  rw [mem_liftCharge_iff_exists𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toFluxesTen.NoExoticsh2:x.toFluxesTen.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ ∃ a,
  a.reduce = x ∧
    a.toCharges.toFinset = c ∧
      (a.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
        a.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }})𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toFluxesTen.NoExoticsh2:x.toFluxesTen.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ ∃ a,
  a.reduce = x ∧
    a.toCharges.toFinset = c ∧
      (a.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
        a.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }})]𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toFluxesTen.NoExoticsh2:x.toFluxesTen.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ ∃ a,
  a.reduce = x ∧
    a.toCharges.toFinset = c ∧
      (a.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
        a.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }})
  refine ⟨x.decompose, ?_, ?_, ?_⟩refine_1𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toFluxesTen.NoExoticsh2:x.toFluxesTen.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ x.decompose.reduce = xrefine_2𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toFluxesTen.NoExoticsh2:x.toFluxesTen.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ x.decompose.toCharges.toFinset = crefine_3𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toFluxesTen.NoExoticsh2:x.toFluxesTen.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ x.decompose.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
  x.decompose.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }}
  ·refine_1𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toFluxesTen.NoExoticsh2:x.toFluxesTen.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ x.decompose.reduce = x rw [decompose_reduce x hfrefine_1𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toFluxesTen.NoExoticsh2:x.toFluxesTen.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ x.reduce = xrefine_1𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toFluxesTen.NoExoticsh2:x.toFluxesTen.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ x.reduce = x]refine_1𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toFluxesTen.NoExoticsh2:x.toFluxesTen.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ x.reduce = x
    exact reduce_eq_self_of_ofCharges_nodup x h4All goals completed! 🐙
  ·refine_2𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toFluxesTen.NoExoticsh2:x.toFluxesTen.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ x.decompose.toCharges.toFinset = c trans x.decompose.toCharges.dedup.toFinset𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toFluxesTen.NoExoticsh2:x.toFluxesTen.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ x.decompose.toCharges.toFinset = x.decompose.toCharges.dedup.toFinset𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toFluxesTen.NoExoticsh2:x.toFluxesTen.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ x.decompose.toCharges.dedup.toFinset = c
    ·𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toFluxesTen.NoExoticsh2:x.toFluxesTen.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ x.decompose.toCharges.toFinset = x.decompose.toCharges.dedup.toFinset simpAll goals completed! 🐙
    ·𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toFluxesTen.NoExoticsh2:x.toFluxesTen.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ x.decompose.toCharges.dedup.toFinset = c rw [decompose_toCharges_dedup x hf,𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toFluxesTen.NoExoticsh2:x.toFluxesTen.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ x.toCharges.dedup.toFinset = c𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toFluxesTen.NoExoticsh2:x.toFluxesTen.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ x.toCharges.dedup.toFinset = x.toCharges.toFinset ← h3𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toFluxesTen.NoExoticsh2:x.toFluxesTen.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ x.toCharges.dedup.toFinset = x.toCharges.toFinset𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toFluxesTen.NoExoticsh2:x.toFluxesTen.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ x.toCharges.dedup.toFinset = x.toCharges.toFinset]𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toFluxesTen.NoExoticsh2:x.toFluxesTen.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ x.toCharges.dedup.toFinset = x.toCharges.toFinset
      simpAll goals completed! 🐙
  ·refine_3𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toFluxesTen.NoExoticsh2:x.toFluxesTen.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesTen ∈ FluxesTen.elemsNoExotics⊢ x.decompose.toFluxesTen = {{ M := 1, N := 0 }, { M := 1, N := 0 }, { M := 1, N := 0 }} ∨
  x.decompose.toFluxesTen = {{ M := 1, N := 1 }, { M := 1, N := -1 }, { M := 1, N := 0 }} exact decompose_toFluxesTen x hfAll goals completed! 🐙



lemma mem_liftCharge_iff (c : Finset 𝓩) (x : TenQuanta 𝓩) :
    x ∈ liftCharge c ↔ x.toFluxesTen ∈ FluxesTen.elemsNoExotics
      ∧ x.toCharges.toFinset = c ∧ x.toCharges.Nodup := by𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩⊢ x ∈ liftCharge c ↔ x.toFluxesTen ∈ FluxesTen.elemsNoExotics ∧ x.toCharges.toFinset = c ∧ x.toCharges.Nodup
  constructormp𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩⊢ x ∈ liftCharge c → x.toFluxesTen ∈ FluxesTen.elemsNoExotics ∧ x.toCharges.toFinset = c ∧ x.toCharges.Nodupmpr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩⊢ x.toFluxesTen ∈ FluxesTen.elemsNoExotics ∧ x.toCharges.toFinset = c ∧ x.toCharges.Nodup → x ∈ liftCharge c
  ·mp𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩⊢ x ∈ liftCharge c → x.toFluxesTen ∈ FluxesTen.elemsNoExotics ∧ x.toCharges.toFinset = c ∧ x.toCharges.Nodup intro hmp𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x ∈ liftCharge c⊢ x.toFluxesTen ∈ FluxesTen.elemsNoExotics ∧ x.toCharges.toFinset = c ∧ x.toCharges.Nodup
    refine ⟨?_, ?_, ?_⟩mp.refine_1𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x ∈ liftCharge c⊢ x.toFluxesTen ∈ FluxesTen.elemsNoExoticsmp.refine_2𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x ∈ liftCharge c⊢ x.toCharges.toFinset = cmp.refine_3𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x ∈ liftCharge c⊢ x.toCharges.Nodup
    ·mp.refine_1𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x ∈ liftCharge c⊢ x.toFluxesTen ∈ FluxesTen.elemsNoExotics rw [← FluxesTen.noExotics_iff_mem_elemsNoExoticsmp.refine_1𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x ∈ liftCharge c⊢ x.toFluxesTen.NoExotics ∧ x.toFluxesTen.HasNoZeromp.refine_1𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x ∈ liftCharge c⊢ x.toFluxesTen.NoExotics ∧ x.toFluxesTen.HasNoZero]mp.refine_1𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x ∈ liftCharge c⊢ x.toFluxesTen.NoExotics ∧ x.toFluxesTen.HasNoZero
      exact ⟨noExotics_of_mem_liftCharge c x h, hasNoZero_of_mem_liftCharge c h⟩All goals completed! 🐙
    ·mp.refine_2𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x ∈ liftCharge c⊢ x.toCharges.toFinset = c exact toCharge_toFinset_of_mem_liftCharge c hAll goals completed! 🐙
    ·mp.refine_3𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h:x ∈ liftCharge c⊢ x.toCharges.Nodup exact toCharges_nodup_of_mem_liftCharge c hAll goals completed! 🐙
  ·mpr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩⊢ x.toFluxesTen ∈ FluxesTen.elemsNoExotics ∧ x.toCharges.toFinset = c ∧ x.toCharges.Nodup → x ∈ liftCharge c intro ⟨h1, h2, h3⟩mpr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toFluxesTen ∈ FluxesTen.elemsNoExoticsh2:x.toCharges.toFinset = ch3:x.toCharges.Nodup⊢ x ∈ liftCharge c
    rw [← FluxesTen.noExotics_iff_mem_elemsNoExoticsmpr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toFluxesTen.NoExotics ∧ x.toFluxesTen.HasNoZeroh2:x.toCharges.toFinset = ch3:x.toCharges.Nodup⊢ x ∈ liftCharge cmpr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toFluxesTen.NoExotics ∧ x.toFluxesTen.HasNoZeroh2:x.toCharges.toFinset = ch3:x.toCharges.Nodup⊢ x ∈ liftCharge c] at h1mpr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:TenQuanta 𝓩h1:x.toFluxesTen.NoExotics ∧ x.toFluxesTen.HasNoZeroh2:x.toCharges.toFinset = ch3:x.toCharges.Nodup⊢ x ∈ liftCharge c
    exact mem_liftCharge_of_mem_noExotics_hasNoZero c h1.1 h1.2 h2 h3All goals completed! 🐙

D.8. `liftCharge c` is preserved under a map if reduced



lemma map_liftCharge {𝓩 𝓩1 : Type}[DecidableEq 𝓩] [DecidableEq 𝓩1] [CommRing 𝓩] [CommRing 𝓩1]
    (f : 𝓩 →+* 𝓩1) (c : Finset 𝓩) (F : TenQuanta 𝓩) (h : F ∈ liftCharge c) :
    TenQuanta.reduce (F.map fun y => (f y.1, y.2)) ∈ liftCharge (c.image f) := by𝓩:Type𝓩1:Typeinst✝³:DecidableEq 𝓩inst✝²:DecidableEq 𝓩1inst✝¹:CommRing 𝓩inst✝:CommRing 𝓩1f:𝓩 →+* 𝓩1c:Finset 𝓩F:TenQuanta 𝓩h:F ∈ liftCharge c⊢ reduce (Multiset.map (fun y => (f y.1, y.2)) F) ∈ liftCharge (Finset.image (⇑f) c)
  rw [mem_liftCharge_iff𝓩:Type𝓩1:Typeinst✝³:DecidableEq 𝓩inst✝²:DecidableEq 𝓩1inst✝¹:CommRing 𝓩inst✝:CommRing 𝓩1f:𝓩 →+* 𝓩1c:Finset 𝓩F:TenQuanta 𝓩h:F.toFluxesTen ∈ FluxesTen.elemsNoExotics ∧ F.toCharges.toFinset = c ∧ F.toCharges.Nodup⊢ (reduce (Multiset.map (fun y => (f y.1, y.2)) F)).toFluxesTen ∈ FluxesTen.elemsNoExotics ∧
  (reduce (Multiset.map (fun y => (f y.1, y.2)) F)).toCharges.toFinset = Finset.image (⇑f) c ∧
    (reduce (Multiset.map (fun y => (f y.1, y.2)) F)).toCharges.Nodup𝓩:Type𝓩1:Typeinst✝³:DecidableEq 𝓩inst✝²:DecidableEq 𝓩1inst✝¹:CommRing 𝓩inst✝:CommRing 𝓩1f:𝓩 →+* 𝓩1c:Finset 𝓩F:TenQuanta 𝓩h:F.toFluxesTen ∈ FluxesTen.elemsNoExotics ∧ F.toCharges.toFinset = c ∧ F.toCharges.Nodup⊢ (reduce (Multiset.map (fun y => (f y.1, y.2)) F)).toFluxesTen ∈ FluxesTen.elemsNoExotics ∧
  (reduce (Multiset.map (fun y => (f y.1, y.2)) F)).toCharges.toFinset = Finset.image (⇑f) c ∧
    (reduce (Multiset.map (fun y => (f y.1, y.2)) F)).toCharges.Nodup] at h ⊢𝓩:Type𝓩1:Typeinst✝³:DecidableEq 𝓩inst✝²:DecidableEq 𝓩1inst✝¹:CommRing 𝓩inst✝:CommRing 𝓩1f:𝓩 →+* 𝓩1c:Finset 𝓩F:TenQuanta 𝓩h:F.toFluxesTen ∈ FluxesTen.elemsNoExotics ∧ F.toCharges.toFinset = c ∧ F.toCharges.Nodup⊢ (reduce (Multiset.map (fun y => (f y.1, y.2)) F)).toFluxesTen ∈ FluxesTen.elemsNoExotics ∧
  (reduce (Multiset.map (fun y => (f y.1, y.2)) F)).toCharges.toFinset = Finset.image (⇑f) c ∧
    (reduce (Multiset.map (fun y => (f y.1, y.2)) F)).toCharges.Nodup
  refine ⟨?_, ?_, ?_⟩refine_1𝓩:Type𝓩1:Typeinst✝³:DecidableEq 𝓩inst✝²:DecidableEq 𝓩1inst✝¹:CommRing 𝓩inst✝:CommRing 𝓩1f:𝓩 →+* 𝓩1c:Finset 𝓩F:TenQuanta 𝓩h:F.toFluxesTen ∈ FluxesTen.elemsNoExotics ∧ F.toCharges.toFinset = c ∧ F.toCharges.Nodup⊢ (reduce (Multiset.map (fun y => (f y.1, y.2)) F)).toFluxesTen ∈ FluxesTen.elemsNoExoticsrefine_2𝓩:Type𝓩1:Typeinst✝³:DecidableEq 𝓩inst✝²:DecidableEq 𝓩1inst✝¹:CommRing 𝓩inst✝:CommRing 𝓩1f:𝓩 →+* 𝓩1c:Finset 𝓩F:TenQuanta 𝓩h:F.toFluxesTen ∈ FluxesTen.elemsNoExotics ∧ F.toCharges.toFinset = c ∧ F.toCharges.Nodup⊢ (reduce (Multiset.map (fun y => (f y.1, y.2)) F)).toCharges.toFinset = Finset.image (⇑f) crefine_3𝓩:Type𝓩1:Typeinst✝³:DecidableEq 𝓩inst✝²:DecidableEq 𝓩1inst✝¹:CommRing 𝓩inst✝:CommRing 𝓩1f:𝓩 →+* 𝓩1c:Finset 𝓩F:TenQuanta 𝓩h:F.toFluxesTen ∈ FluxesTen.elemsNoExotics ∧ F.toCharges.toFinset = c ∧ F.toCharges.Nodup⊢ (reduce (Multiset.map (fun y => (f y.1, y.2)) F)).toCharges.Nodup
  ·refine_1𝓩:Type𝓩1:Typeinst✝³:DecidableEq 𝓩inst✝²:DecidableEq 𝓩1inst✝¹:CommRing 𝓩inst✝:CommRing 𝓩1f:𝓩 →+* 𝓩1c:Finset 𝓩F:TenQuanta 𝓩h:F.toFluxesTen ∈ FluxesTen.elemsNoExotics ∧ F.toCharges.toFinset = c ∧ F.toCharges.Nodup⊢ (reduce (Multiset.map (fun y => (f y.1, y.2)) F)).toFluxesTen ∈ FluxesTen.elemsNoExotics apply reduce_mem_elemsNoExoticsrefine_1𝓩:Type𝓩1:Typeinst✝³:DecidableEq 𝓩inst✝²:DecidableEq 𝓩1inst✝¹:CommRing 𝓩inst✝:CommRing 𝓩1f:𝓩 →+* 𝓩1c:Finset 𝓩F:TenQuanta 𝓩h:F.toFluxesTen ∈ FluxesTen.elemsNoExotics ∧ F.toCharges.toFinset = c ∧ F.toCharges.Nodup⊢ toFluxesTen (Multiset.map (fun y => (f y.1, y.2)) F) ∈ FluxesTen.elemsNoExotics
    simpa [toFluxesTen, Multiset.map_map] using h.1All goals completed! 🐙
  ·refine_2𝓩:Type𝓩1:Typeinst✝³:DecidableEq 𝓩inst✝²:DecidableEq 𝓩1inst✝¹:CommRing 𝓩inst✝:CommRing 𝓩1f:𝓩 →+* 𝓩1c:Finset 𝓩F:TenQuanta 𝓩h:F.toFluxesTen ∈ FluxesTen.elemsNoExotics ∧ F.toCharges.toFinset = c ∧ F.toCharges.Nodup⊢ (reduce (Multiset.map (fun y => (f y.1, y.2)) F)).toCharges.toFinset = Finset.image (⇑f) c rw [reduce_toChargesrefine_2𝓩:Type𝓩1:Typeinst✝³:DecidableEq 𝓩inst✝²:DecidableEq 𝓩1inst✝¹:CommRing 𝓩inst✝:CommRing 𝓩1f:𝓩 →+* 𝓩1c:Finset 𝓩F:TenQuanta 𝓩h:F.toFluxesTen ∈ FluxesTen.elemsNoExotics ∧ F.toCharges.toFinset = c ∧ F.toCharges.Nodup⊢ (toCharges (Multiset.map (fun y => (f y.1, y.2)) F)).dedup.toFinset = Finset.image (⇑f) crefine_2𝓩:Type𝓩1:Typeinst✝³:DecidableEq 𝓩inst✝²:DecidableEq 𝓩1inst✝¹:CommRing 𝓩inst✝:CommRing 𝓩1f:𝓩 →+* 𝓩1c:Finset 𝓩F:TenQuanta 𝓩h:F.toFluxesTen ∈ FluxesTen.elemsNoExotics ∧ F.toCharges.toFinset = c ∧ F.toCharges.Nodup⊢ (toCharges (Multiset.map (fun y => (f y.1, y.2)) F)).dedup.toFinset = Finset.image (⇑f) c]refine_2𝓩:Type𝓩1:Typeinst✝³:DecidableEq 𝓩inst✝²:DecidableEq 𝓩1inst✝¹:CommRing 𝓩inst✝:CommRing 𝓩1f:𝓩 →+* 𝓩1c:Finset 𝓩F:TenQuanta 𝓩h:F.toFluxesTen ∈ FluxesTen.elemsNoExotics ∧ F.toCharges.toFinset = c ∧ F.toCharges.Nodup⊢ (toCharges (Multiset.map (fun y => (f y.1, y.2)) F)).dedup.toFinset = Finset.image (⇑f) c
    simp [← h.2.1, ← Multiset.toFinset_map, toCharges]All goals completed! 🐙
  ·refine_3𝓩:Type𝓩1:Typeinst✝³:DecidableEq 𝓩inst✝²:DecidableEq 𝓩1inst✝¹:CommRing 𝓩inst✝:CommRing 𝓩1f:𝓩 →+* 𝓩1c:Finset 𝓩F:TenQuanta 𝓩h:F.toFluxesTen ∈ FluxesTen.elemsNoExotics ∧ F.toCharges.toFinset = c ∧ F.toCharges.Nodup⊢ (reduce (Multiset.map (fun y => (f y.1, y.2)) F)).toCharges.Nodup rw [reduce_toChargesrefine_3𝓩:Type𝓩1:Typeinst✝³:DecidableEq 𝓩inst✝²:DecidableEq 𝓩1inst✝¹:CommRing 𝓩inst✝:CommRing 𝓩1f:𝓩 →+* 𝓩1c:Finset 𝓩F:TenQuanta 𝓩h:F.toFluxesTen ∈ FluxesTen.elemsNoExotics ∧ F.toCharges.toFinset = c ∧ F.toCharges.Nodup⊢ (toCharges (Multiset.map (fun y => (f y.1, y.2)) F)).dedup.Noduprefine_3𝓩:Type𝓩1:Typeinst✝³:DecidableEq 𝓩inst✝²:DecidableEq 𝓩1inst✝¹:CommRing 𝓩inst✝:CommRing 𝓩1f:𝓩 →+* 𝓩1c:Finset 𝓩F:TenQuanta 𝓩h:F.toFluxesTen ∈ FluxesTen.elemsNoExotics ∧ F.toCharges.toFinset = c ∧ F.toCharges.Nodup⊢ (toCharges (Multiset.map (fun y => (f y.1, y.2)) F)).dedup.Nodup]refine_3𝓩:Type𝓩1:Typeinst✝³:DecidableEq 𝓩inst✝²:DecidableEq 𝓩1inst✝¹:CommRing 𝓩inst✝:CommRing 𝓩1f:𝓩 →+* 𝓩1c:Finset 𝓩F:TenQuanta 𝓩h:F.toFluxesTen ∈ FluxesTen.elemsNoExotics ∧ F.toCharges.toFinset = c ∧ F.toCharges.Nodup⊢ (toCharges (Multiset.map (fun y => (f y.1, y.2)) F)).dedup.Nodup
    exact Multiset.nodup_dedup (toCharges (Multiset.map (fun y => (f y.1, y.2)) F))All goals completed! 🐙

E. Anomaly cancellation coefficients

E.1. Anomaly coefficients of a `TenQuanta`

The anomaly coefficient of a TenQuanta is given by the pair of integers: (∑ᵢ qᵢ Nᵢ, 3 * ∑ᵢ qᵢ² Nᵢ).

The first components is for the mixed U(1)-MSSM, see equation (22) of arXiv:1401.5084. The second component is for the mixed U(1)Y-U(1)-U(1) gauge anomaly, see equation (23) of arXiv:1401.5084.

def anomalyCoefficient (F : TenQuanta 𝓩) : 𝓩 × 𝓩 :=
  ((F.map fun x => x.2.2 • x.1).sum, 3 * (F.map fun x => x.2.2 • (x.1 * x.1)).sum)

E.2. Anomaly coefficients under a map

@[simp]
lemma anomalyCoefficient_of_map {𝓩 𝓩1 : Type} [CommRing 𝓩] [CommRing 𝓩1]
    (f : 𝓩 →+* 𝓩1) (F : TenQuanta 𝓩) :
    TenQuanta.anomalyCoefficient (F.map fun y => (f y.1, y.2) : TenQuanta 𝓩1) =
    (f.prodMap f) F.anomalyCoefficient := by𝓩:Type𝓩1:Typeinst✝¹:CommRing 𝓩inst✝:CommRing 𝓩1f:𝓩 →+* 𝓩1F:TenQuanta 𝓩⊢ anomalyCoefficient (Multiset.map (fun y => (f y.1, y.2)) F) = (f.prodMap f) F.anomalyCoefficient
  simp [TenQuanta.anomalyCoefficient, map_multiset_sum, Multiset.map_map, map_ofNat]All goals completed! 🐙

E.3. Anomaly coefficients is preserved under `reduce`



lemma anomalyCoefficient_of_reduce [DecidableEq 𝓩] (F : TenQuanta 𝓩) :
    F.reduce.anomalyCoefficient = F.anomalyCoefficient := by𝓩:Typeinst✝¹:CommRing 𝓩inst✝:DecidableEq 𝓩F:TenQuanta 𝓩⊢ F.reduce.anomalyCoefficient = F.anomalyCoefficient
  have weighted_N_sum_eq : ∀ w : 𝓩 → 𝓩,
      (Multiset.map (fun x => (x.2.N : 𝓩) * w x.1) F.reduce).sum =
      (Multiset.map (fun x => (x.2.N : 𝓩) * w x.1) F).sum := fun w =>
    reduce_sum_eq_sum_toCharges F fun q5 =>
      { toFun := fun x => (x.N : 𝓩) * w q5
        map_zero' := by𝓩:Typeinst✝¹:CommRing 𝓩inst✝:DecidableEq 𝓩F:TenQuanta 𝓩w:𝓩 → 𝓩q5:𝓩⊢ ↑(Fluxes.N 0) * w q5 = 0𝓩:Typeinst✝¹:CommRing 𝓩inst✝:DecidableEq 𝓩F:TenQuanta 𝓩weighted_N_sum_eq:∀ (w : 𝓩 → 𝓩), (Multiset.map (fun x => ↑x.2.N * w x.1) F.reduce).sum = (Multiset.map (fun x => ↑x.2.N * w x.1) F).sum⊢ F.reduce.anomalyCoefficient = F.anomalyCoefficient simpAll goals completed! 🐙𝓩:Typeinst✝¹:CommRing 𝓩inst✝:DecidableEq 𝓩F:TenQuanta 𝓩weighted_N_sum_eq:∀ (w : 𝓩 → 𝓩), (Multiset.map (fun x => ↑x.2.N * w x.1) F.reduce).sum = (Multiset.map (fun x => ↑x.2.N * w x.1) F).sum⊢ F.reduce.anomalyCoefficient = F.anomalyCoefficient
        map_add' := fun x y => by𝓩:Typeinst✝¹:CommRing 𝓩inst✝:DecidableEq 𝓩F:TenQuanta 𝓩w:𝓩 → 𝓩q5:𝓩x:Fluxesy:Fluxes⊢ ↑(x + y).N * w q5 = ↑x.N * w q5 + ↑y.N * w q5𝓩:Typeinst✝¹:CommRing 𝓩inst✝:DecidableEq 𝓩F:TenQuanta 𝓩weighted_N_sum_eq:∀ (w : 𝓩 → 𝓩), (Multiset.map (fun x => ↑x.2.N * w x.1) F.reduce).sum = (Multiset.map (fun x => ↑x.2.N * w x.1) F).sum⊢ F.reduce.anomalyCoefficient = F.anomalyCoefficient simp [add_mul]All goals completed! 🐙𝓩:Typeinst✝¹:CommRing 𝓩inst✝:DecidableEq 𝓩F:TenQuanta 𝓩weighted_N_sum_eq:∀ (w : 𝓩 → 𝓩), (Multiset.map (fun x => ↑x.2.N * w x.1) F.reduce).sum = (Multiset.map (fun x => ↑x.2.N * w x.1) F).sum⊢ F.reduce.anomalyCoefficient = F.anomalyCoefficient }𝓩:Typeinst✝¹:CommRing 𝓩inst✝:DecidableEq 𝓩F:TenQuanta 𝓩weighted_N_sum_eq:∀ (w : 𝓩 → 𝓩), (Multiset.map (fun x => ↑x.2.N * w x.1) F.reduce).sum = (Multiset.map (fun x => ↑x.2.N * w x.1) F).sum⊢ F.reduce.anomalyCoefficient = F.anomalyCoefficient
  simp [anomalyCoefficient]𝓩:Typeinst✝¹:CommRing 𝓩inst✝:DecidableEq 𝓩F:TenQuanta 𝓩weighted_N_sum_eq:∀ (w : 𝓩 → 𝓩), (Multiset.map (fun x => ↑x.2.N * w x.1) F.reduce).sum = (Multiset.map (fun x => ↑x.2.N * w x.1) F).sum⊢ (Multiset.map (fun x => ↑x.2.N * x.1) F.reduce).sum = (Multiset.map (fun x => ↑x.2.N * x.1) F).sum ∧
  3 * (Multiset.map (fun x => ↑x.2.N * (x.1 * x.1)) F.reduce).sum =
    3 * (Multiset.map (fun x => ↑x.2.N * (x.1 * x.1)) F).sum
  exact ⟨weighted_N_sum_eq fun q => q, congrArg (3 * ·) (weighted_N_sum_eq fun q => q * q)⟩All goals completed! 🐙

Quanta of 10d representations

i. Overview

ii. Key results

iii. Table of contents

iv. References

A. The definition of TenQuanta

A.1. The map to underlying fluxes

A.2. The map to underlying charges

A.3. The map from charges to fluxes

B. The reduction of a TenQuanta

B.1. The reduced TenQuanta has no duplicate elements

B.2. The underlying charges of the reduced TenQuanta are the deduped charges

B.3. Membership condition on the reduced TenQuanta

B.4. Filter of the reduced TenQuanta by a charge

B.5. The reduction is idempotent

B.6. Preservation of certain sums under reduction

B.7. Reduction does nothing if no duplicate charges

B.8. The charge map is preserved by reduction

B.9. A fluxes in the reduced TenQuanta is a sum of fluxes in the original TenQuanta

B.10. No exotics condition on the reduced TenQuanta

B.10.1. Number of chiral U

B.10.2. Number of anti-chiral U

B.10.3. Number of chiral Q

B.10.4. Number of anti-chiral Q

B.10.5. Number of chiral E

B.10.6. Number of anti-chiral E

B.10.7. The NoExotics condition on the reduced TenQuanta

B.11. Reduce member of FLuxesTen.elemsNoExotics

C. Decomposition of a TenQuanta into basic fluxes

C.1. Decomposition of fluxes

C.2. Decomposition of a TenQuanta (with no exotics)

C.2.1. Decomposition distributes over addition

C.2.2. Decomposition commutes with filtering charges

C.2.3. Decomposition preserves the charge map

C.2.4. Decomposition preserves the charges

C.2.5. Decomposition preserves the reduction

C.2.6. Fluxes of the decomposition of a TenQuanta

D. Lifting charges to TenQuanta

D.1. liftCharge c: multiset of ten-quanta for a finite set of charges c with no exotics

D.2. TenQuanta in liftCharge c have a finite set of charges c

D.3. TenQuanta in liftCharge c have no duplicate charges

D.4. Membership in liftCharge c iff is reduction of TenQuanta with given fluxes

D.5. TenQuanta in liftCharge c do not have zero fluxes

D.6. TenQuanta in liftCharge c have no exotics

D.7. Membership in liftCharge c iff have no exotics, no zero fluxes, and charges c

D.8. liftCharge c is preserved under a map if reduced

E. Anomaly cancellation coefficients

E.1. Anomaly coefficients of a TenQuanta

E.2. Anomaly coefficients under a map

E.3. Anomaly coefficients is preserved under reduce

A. The definition of `TenQuanta`

B. The reduction of a `TenQuanta`

B.1. The reduced `TenQuanta` has no duplicate elements

B.2. The underlying charges of the reduced `TenQuanta` are the deduped charges

B.3. Membership condition on the reduced `TenQuanta`

B.4. Filter of the reduced `TenQuanta` by a charge

B.9. A fluxes in the reduced `TenQuanta` is a sum of fluxes in the original `TenQuanta`

B.10. No exotics condition on the reduced `TenQuanta`

B.10.1. Number of chiral `U`

B.10.2. Number of anti-chiral `U`

B.10.3. Number of chiral `Q`

B.10.4. Number of anti-chiral `Q`

B.10.5. Number of chiral `E`

B.10.6. Number of anti-chiral `E`

B.10.7. The `NoExotics` condition on the reduced `TenQuanta`

B.11. Reduce member of `FLuxesTen.elemsNoExotics`

C. Decomposition of a `TenQuanta` into basic fluxes

C.2. Decomposition of a `TenQuanta` (with no exotics)

C.2.6. Fluxes of the decomposition of a `TenQuanta`

D. Lifting charges to `TenQuanta`

D.1. `liftCharge c`: multiset of ten-quanta for a finite set of charges `c` with no exotics

D.2. TenQuanta in `liftCharge c` have a finite set of charges `c`

D.3. TenQuanta in `liftCharge c` have no duplicate charges

D.4. Membership in `liftCharge c` iff is reduction of `TenQuanta` with given fluxes

D.5. TenQuanta in `liftCharge c` do not have zero fluxes

D.6. TenQuanta in `liftCharge c` have no exotics

D.7. Membership in `liftCharge c` iff have no exotics, no zero fluxes, and charges `c`

D.8. `liftCharge c` is preserved under a map if reduced

E.1. Anomaly coefficients of a `TenQuanta`

E.3. Anomaly coefficients is preserved under `reduce`