Physlib.StringTheory.FTheory.SU5.Quanta.FiveQuanta

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 5-d representations

i. Overview

The 5-bar 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

FiveQuanta is the type of quanta of 5-bar representations.

FiveQuanta.toFluxesFive is the underlying FluxesFive of a FiveQuanta.

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

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

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

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

iii. Table of contents

A. The definition of FiveQuanta

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 FiveQuanta

B.1. The reduced FiveQuanta has no duplicate elements

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

B.3. Membership condition on the reduced FiveQuanta

B.4. Filter of the reduced FiveQuanta 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 FiveQuanta is a sum of fluxes in the original FiveQuanta

B.10. No exotics condition on the reduced FiveQuanta

B.10.1. Number of chiral L

B.10.2. Number of anti-chiral L

B.10.3. Number of chiral D

B.10.4. Number of anti-chiral D

B.10.5. The NoExotics condition on the reduced FiveQuanta

B.11. Reduce member of FluxesFive.elemsNoExotics

C. Decomposition of a FiveQuanta into basic fluxes

C.1. Decomposition of fluxes

C.2. Decomposition of a FiveQuanta (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 FiveQuanta

D. Lifting charges to FiveQuanta

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

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

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

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

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

D.6. FiveQuanta 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 FiveQuanta

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 `FiveQuanta`

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

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

A.1. The map to underlying fluxes

The underlying FluxesFive from a FiveQuanta.

def toFluxesFive (x : FiveQuanta 𝓩) : FluxesFive := x.map Prod.snd

A.2. The map to underlying charges

The underlying Multiset charges from a FiveQuanta.

def toCharges (x : FiveQuanta 𝓩) : 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 FiveQuanta.

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



lemma toChargeMap_of_not_mem [DecidableEq 𝓩] (x : FiveQuanta 𝓩) {z : 𝓩} (h : z ∉ x.toCharges) :
    x.toChargeMap z = 0 := by𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩z:𝓩h:z ∉ x.toCharges⊢ x.toChargeMap z = 0
  have hl : Multiset.filter (fun p => p.1 = z) x = 0 := by
    rw [Multiset.filter_eq_nil𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩z:𝓩h:z ∉ x.toCharges⊢ ∀ a ∈ x, ¬a.1 = z𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩z:𝓩h:z ∉ x.toCharges⊢ ∀ a ∈ x, ¬a.1 = z𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩z:𝓩h:z ∉ x.toChargeshl:Multiset.filter (fun p => p.1 = z) x = 0⊢ x.toChargeMap z = 0]𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩z:𝓩h:z ∉ x.toCharges⊢ ∀ a ∈ x, ¬a.1 = z𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩z:𝓩h:z ∉ x.toChargeshl:Multiset.filter (fun p => p.1 = z) x = 0⊢ x.toChargeMap z = 0
    rintro ⟨a, b⟩ hab rfl𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩a:𝓩b:Fluxeshab:(a, b) ∈ xh:(a, b).1 ∉ x.toCharges⊢ False𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩z:𝓩h:z ∉ x.toChargeshl:Multiset.filter (fun p => p.1 = z) x = 0⊢ x.toChargeMap z = 0
    exact h (Multiset.mem_map_of_mem Prod.fst hab)𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩z:𝓩h:z ∉ x.toChargeshl:Multiset.filter (fun p => p.1 = z) x = 0⊢ x.toChargeMap z = 0𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩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 `FiveQuanta`

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

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

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



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

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

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

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

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

lemma mem_reduce_iff (x : FiveQuanta 𝓩) (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:FiveQuanta 𝓩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:FiveQuanta 𝓩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
  aesopAll goals completed! 🐙

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

lemma reduce_filter (x : FiveQuanta 𝓩) (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:FiveQuanta 𝓩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, Multiset.filter_map, Function.comp, Multiset.filter_eq', h]All goals completed! 🐙

B.5. The reduction is idempotent



@[simp]
lemma reduce_reduce (x : FiveQuanta 𝓩) :
    x.reduce.reduce = x.reduce := by𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩⊢ x.reduce.reduce = x.reduce
  refine Multiset.Nodup.toFinset_inj (reduce_nodup x.reduce) (reduce_nodup x) ?_𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩⊢ Multiset.toFinset x.reduce.reduce = Multiset.toFinset x.reduce
  ext p𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩p:𝓩 × Fluxes⊢ p ∈ Multiset.toFinset x.reduce.reduce ↔ p ∈ Multiset.toFinset x.reduce
  simp only [Multiset.mem_toFinset]𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩p:𝓩 × Fluxes⊢ p ∈ x.reduce.reduce ↔ p ∈ x.reduce
  rw [mem_reduce_iff,𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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)).sum𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩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)).sum]𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩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)).sum
  simpAll goals completed! 🐙

B.6. Preservation of certain sums under reduction



lemma reduce_sum_eq_sum_toCharges {M} [AddCommMonoid M] (x : FiveQuanta 𝓩) (f : 𝓩 → Fluxes →+ M) :
    (x.reduce.map fun (q5, x) => f q5 x).sum = (x.map fun (q5, x) => f q5 x).sum := by𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:FiveQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ (Multiset.map
      (fun x =>
        match x with
        | (q5, x) => (f q5) x)
      x.reduce).sum =
  (Multiset.map
      (fun x =>
        match x with
        | (q5, x) => (f q5) x)
      x).sum
  calc _
      _ = ∑ q5 ∈ x.toCharges.toFinset,
          f q5 ((x.filter (fun f => f.1 = q5)).map (fun y => y.2)).sum := by𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:FiveQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ (Multiset.map
      (fun x =>
        match x with
        | (q5, x) => (f q5) x)
      x.reduce).sum =
  ∑ q5 ∈ x.toCharges.toFinset, (f q5) (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q5) x)).sum
        rw [reduce𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:FiveQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ (Multiset.map
      (fun x =>
        match x with
        | (q5, x) => (f q5) x)
      (Multiset.map (fun q5 => (q5, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q5) x)).sum))
        x.toCharges.dedup)).sum =
  ∑ q5 ∈ x.toCharges.toFinset, (f q5) (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q5) x)).sum𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:FiveQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ (Multiset.map
      (fun x =>
        match x with
        | (q5, x) => (f q5) x)
      (Multiset.map (fun q5 => (q5, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q5) x)).sum))
        x.toCharges.dedup)).sum =
  ∑ q5 ∈ x.toCharges.toFinset, (f q5) (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q5) x)).sum]𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:FiveQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ (Multiset.map
      (fun x =>
        match x with
        | (q5, x) => (f q5) x)
      (Multiset.map (fun q5 => (q5, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q5) x)).sum))
        x.toCharges.dedup)).sum =
  ∑ q5 ∈ x.toCharges.toFinset, (f q5) (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q5) x)).sum
        simp [Finset.sum]All goals completed! 🐙
      _ = ∑ q5 ∈ x.toCharges.toFinset,
          (((x.filter (fun f => f.1 = q5)).map (fun y => f q5 y.2))).sum := by𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:FiveQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ ∑ q5 ∈ x.toCharges.toFinset, (f q5) (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q5) x)).sum =
  ∑ q5 ∈ x.toCharges.toFinset, (Multiset.map (fun y => (f q5) y.2) (Multiset.filter (fun f => f.1 = q5) x)).sum
        congre_f𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:FiveQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ (fun q5 => (f q5) (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q5) x)).sum) = fun q5 =>
  (Multiset.map (fun y => (f q5) y.2) (Multiset.filter (fun f => f.1 = q5) x)).sum
        funext q5e_f𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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 q5 =>
          ((x.filter (fun f => f.1 = q5)).map (fun y => f q5 y.2))).sum := by𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:FiveQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ ∑ q5 ∈ x.toCharges.toFinset, (Multiset.map (fun y => (f q5) y.2) (Multiset.filter (fun f => f.1 = q5) x)).sum =
  (x.toCharges.dedup.bind fun q5 => Multiset.map (fun y => (f q5) y.2) (Multiset.filter (fun f => f.1 = q5) x)).sum
        rw [Multiset.sum_bind𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:FiveQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ ∑ q5 ∈ x.toCharges.toFinset, (Multiset.map (fun y => (f q5) y.2) (Multiset.filter (fun f => f.1 = q5) 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:FiveQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ ∑ q5 ∈ x.toCharges.toFinset, (Multiset.map (fun y => (f q5) y.2) (Multiset.filter (fun f => f.1 = q5) 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:FiveQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ ∑ q5 ∈ x.toCharges.toFinset, (Multiset.map (fun y => (f q5) y.2) (Multiset.filter (fun f => f.1 = q5) 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 q5 =>
          ((x.filter (fun f => f.1 = q5)))).map (fun y => f y.1 y.2))).sum := by𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:FiveQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ (x.toCharges.dedup.bind fun q5 => Multiset.map (fun y => (f q5) y.2) (Multiset.filter (fun f => f.1 = q5) x)).sum =
  (Multiset.map (fun y => (f y.1) y.2) (x.toCharges.dedup.bind fun q5 => Multiset.filter (fun f => f.1 = q5) x)).sum
        congr𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:FiveQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ (x.toCharges.dedup.bind fun q5 => Multiset.map (fun y => (f q5) y.2) (Multiset.filter (fun f => f.1 = q5) x)) =
  Multiset.map (fun y => (f y.1) y.2) (x.toCharges.dedup.bind fun q5 => Multiset.filter (fun f => f.1 = q5) x)
        rw [Multiset.map_bind𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:FiveQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ (x.toCharges.dedup.bind fun q5 => Multiset.map (fun y => (f q5) y.2) (Multiset.filter (fun f => f.1 = q5) 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:FiveQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ (x.toCharges.dedup.bind fun q5 => Multiset.map (fun y => (f q5) y.2) (Multiset.filter (fun f => f.1 = q5) 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:FiveQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ (x.toCharges.dedup.bind fun q5 => Multiset.map (fun y => (f q5) y.2) (Multiset.filter (fun f => f.1 = q5) 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:FiveQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ (fun q5 => Multiset.map (fun y => (f q5) y.2) (Multiset.filter (fun f => f.1 = q5) x)) = fun a =>
  Multiset.map (fun y => (f y.1) y.2) (Multiset.filter (fun f => f.1 = a) x)
        funext q5e_f𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:FiveQuanta 𝓩f:𝓩 → Fluxes →+ Mq5:𝓩⊢ Multiset.map (fun y => (f q5) y.2) (Multiset.filter (fun f => f.1 = q5) x) =
  Multiset.map (fun y => (f y.1) y.2) (Multiset.filter (fun f => f.1 = q5) x)
        refine Multiset.map_congr rfl ?_e_f𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:FiveQuanta 𝓩f:𝓩 → Fluxes →+ Mq5:𝓩⊢ ∀ x_1 ∈ Multiset.filter (fun f => f.1 = q5) x, (f q5) x_1.2 = (f x_1.1) x_1.2
        intro y hye_f𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:FiveQuanta 𝓩f:𝓩 → Fluxes →+ Mq5:𝓩y:𝓩 × Fluxeshy:y ∈ Multiset.filter (fun f => f.1 = q5) x⊢ (f q5) y.2 = (f y.1) y.2
        simp at hye_f𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:FiveQuanta 𝓩f:𝓩 → Fluxes →+ Mq5:𝓩y:𝓩 × Fluxeshy:y ∈ x ∧ y.1 = q5⊢ (f q5) y.2 = (f y.1) y.2
        rw [hy.2e_f𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:FiveQuanta 𝓩f:𝓩 → Fluxes →+ Mq5:𝓩y:𝓩 × Fluxeshy:y ∈ x ∧ y.1 = q5⊢ (f q5) y.2 = (f q5) 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:FiveQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ (Multiset.map (fun y => (f y.1) y.2) (x.toCharges.dedup.bind fun q5 => Multiset.filter (fun f => f.1 = q5) x)).sum =
  (Multiset.map (fun y => (f y.1) y.2) x).sum
        congre_s𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:FiveQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ (x.toCharges.dedup.bind fun q5 => Multiset.filter (fun f => f.1 = q5) x) = x
        apply Multiset.ext.mpre_s𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:FiveQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ ∀ (a : 𝓩 × Fluxes),
  Multiset.count a (x.toCharges.dedup.bind fun q5 => Multiset.filter (fun f => f.1 = q5) x) = Multiset.count a x
        intro pe_s𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:FiveQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxes⊢ Multiset.count p (x.toCharges.dedup.bind fun q5 => Multiset.filter (fun f => f.1 = q5) 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:FiveQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxes⊢ Multiset.count p (x.toCharges.dedup.bind fun q5 => Multiset.filter (fun f => f.1 = q5) 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:FiveQuanta 𝓩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:FiveQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxes⊢ Multiset.count p (x.toCharges.dedup.bind fun q5 => Multiset.filter (fun f => f.1 = q5) 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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ (Multiset.map (fun y => (f y.1) y.2) (x.toCharges.dedup.bind fun q5 => Multiset.filter (fun f => f.1 = q5) x)).sum =
  (Multiset.map (fun y => (f y.1) y.2) x).sumpos𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ (Multiset.map (fun y => (f y.1) y.2) (x.toCharges.dedup.bind fun q5 => Multiset.filter (fun f => f.1 = q5) x)).sum =
  (Multiset.map (fun y => (f y.1) y.2) x).sumpos𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∉ Multiset.map Prod.fst x⊢ p ∉ xneg𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:FiveQuanta 𝓩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:FiveQuanta 𝓩f:𝓩 → Fluxes →+ Mp:𝓩 × Fluxesh_mem:p.1 ∉ Multiset.map Prod.fst xh:p ∈ x⊢ Falseneg𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:FiveQuanta 𝓩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:FiveQuanta 𝓩f:𝓩 → Fluxes →+ M⊢ (Multiset.map (fun y => (f y.1) y.2) (x.toCharges.dedup.bind fun q5 => Multiset.filter (fun f => f.1 = q5) x)).sum =
  (Multiset.map (fun y => (f y.1) y.2) x).sumneg𝓩:Typeinst✝¹:DecidableEq 𝓩M:Type u_1inst✝:AddCommMonoid Mx:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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 : FiveQuanta 𝓩) (h : x.toCharges.Nodup) :
    x.reduce = x := by𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩h:x.toCharges.Nodup⊢ x.reduce = x
  rw [reduce,𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩h:x.toCharges.Nodup⊢ Multiset.map (fun q5 => (q5, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q5) x)).sum))
    x.toCharges.dedup =
  x𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩h:x.toCharges.Nodup⊢ Multiset.map (fun q5 => (q5, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q5) x)).sum)) x.toCharges = x Multiset.Nodup.dedup h𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩h:x.toCharges.Nodup⊢ Multiset.map (fun q5 => (q5, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q5) x)).sum)) x.toCharges = x𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩h:x.toCharges.Nodup⊢ Multiset.map (fun q5 => (q5, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q5) x)).sum)) x.toCharges = x]𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩h:x.toCharges.Nodup⊢ Multiset.map (fun q5 => (q5, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q5) x)).sum)) x.toCharges = x
  simp [toCharges]𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩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:FiveQuanta 𝓩h:x.toCharges.Nodup| Multiset.map id x
  apply Multiset.map_congr rfl𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩h:x.toCharges.Nodupp:𝓩 × Fluxeshp:p ∈ xx_noDup:Multiset.Nodup x⊢ Multiset.filter (fun f => f.1 = p.1) x = {p}𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩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 (Multiset.Nodup.filter (fun f => f.1 = p.1) x_noDup)
    (Multiset.nodup_singleton p)).mpr ?_𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩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}
  intro p'𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩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]𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩h:x.toCharges.Nodupp:𝓩 × Fluxeshp:p ∈ xx_noDup:Multiset.Nodup xp':𝓩 × Fluxes⊢ p' ∈ x ∧ p'.1 = p.1 ↔ p' = p
  constructormp𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩h:x.toCharges.Nodupp:𝓩 × Fluxeshp:p ∈ xx_noDup:Multiset.Nodup xp':𝓩 × Fluxes⊢ p' ∈ x ∧ p'.1 = p.1 → p' = pmpr𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩h:x.toCharges.Nodupp:𝓩 × Fluxeshp:p ∈ xx_noDup:Multiset.Nodup xp':𝓩 × Fluxes⊢ p' = p → p' ∈ x ∧ p'.1 = p.1
  ·mp𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩h:x.toCharges.Nodupp:𝓩 × Fluxeshp:p ∈ xx_noDup:Multiset.Nodup xp':𝓩 × Fluxes⊢ p' ∈ x ∧ p'.1 = p.1 → p' = p rintro ⟨h1, h2⟩mp𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩h:x.toCharges.Nodupp:𝓩 × Fluxeshp:p ∈ xx_noDup:Multiset.Nodup xp':𝓩 × Fluxesh1:p' ∈ xh2:p'.1 = p.1⊢ p' = p
    simp [toCharges] at hmp𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩h:(Multiset.map Prod.fst x).Nodupp:𝓩 × Fluxeshp:p ∈ xx_noDup:Multiset.Nodup xp':𝓩 × Fluxesh1:p' ∈ xh2:p'.1 = p.1⊢ p' = p
    rw [propext (Multiset.nodup_map_iff_inj_on x_noDup)mp𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩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' = pmp𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩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 hmp𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩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
    apply hmp.a𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩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' ∈ xmp.a𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩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 ∈ xmp.a𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩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'.1 = p.1
    ·mp.a𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩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' ∈ x exact h1All goals completed! 🐙
    ·mp.a𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩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 ∈ x exact hpAll goals completed! 🐙
    ·mp.a𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩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'.1 = p.1 exact h2All goals completed! 🐙
  ·mpr𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩h:x.toCharges.Nodupp:𝓩 × Fluxeshp:p ∈ xx_noDup:Multiset.Nodup xp':𝓩 × Fluxes⊢ p' = p → p' ∈ x ∧ p'.1 = p.1 rintro ⟨rfl⟩mpr𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩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 : FiveQuanta 𝓩) :
    x.reduce.toChargeMap = x.toChargeMap := by𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩⊢ x.reduce.toChargeMap = x.toChargeMap
  funext q𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩q:𝓩⊢ x.reduce.toChargeMap q = x.toChargeMap q
  by_cases h : q ∈ x.toChargespos𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩q:𝓩h:q ∈ x.toCharges⊢ x.reduce.toChargeMap q = x.toChargeMap qneg𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩q:𝓩h:q ∉ x.toCharges⊢ x.reduce.toChargeMap q = x.toChargeMap q
  ·pos𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩q:𝓩h:q ∈ x.toCharges⊢ x.reduce.toChargeMap q = x.toChargeMap q rw [toChargeMap,pos𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩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:FiveQuanta 𝓩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 reduce_filter x q hpos𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩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𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩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]pos𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩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
    simppos𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩q:𝓩h:q ∈ x.toCharges⊢ (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q) x)).sum = x.toChargeMap q
    rflAll goals completed! 🐙
  ·neg𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩q:𝓩h:q ∉ x.toCharges⊢ x.reduce.toChargeMap q = x.toChargeMap q rw [toChargeMap_of_not_mem,neg𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩q:𝓩h:q ∉ x.toCharges⊢ 0 = x.toChargeMap qneg.h𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩q:𝓩h:q ∉ x.toCharges⊢ q ∉ x.reduce.toChargesneg.h𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩q:𝓩h:q ∉ x.toCharges⊢ q ∉ x.toChargesneg.h𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩q:𝓩h:q ∉ x.toCharges⊢ q ∉ x.reduce.toCharges toChargeMap_of_not_memneg𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩q:𝓩h:q ∉ x.toCharges⊢ 0 = 0neg.h𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩q:𝓩h:q ∉ x.toCharges⊢ q ∉ x.toChargesneg.h𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩q:𝓩h:q ∉ x.toCharges⊢ q ∉ x.reduce.toChargesneg.h𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩q:𝓩h:q ∉ x.toCharges⊢ q ∉ x.toChargesneg.h𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩q:𝓩h:q ∉ x.toCharges⊢ q ∉ x.reduce.toCharges]neg.h𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩q:𝓩h:q ∉ x.toCharges⊢ q ∉ x.toChargesneg.h𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩q:𝓩h:q ∉ x.toCharges⊢ q ∉ x.reduce.toCharges
    ·neg.h𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩q:𝓩h:q ∉ x.toCharges⊢ q ∉ x.toCharges exact hAll goals completed! 🐙
    ·neg.h𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩q:𝓩h:q ∉ x.toCharges⊢ q ∉ x.reduce.toCharges simpa [reduce_toCharges] using hAll goals completed! 🐙

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



lemma mem_powerset_sum_of_mem_reduce_toFluxesFive {F : FiveQuanta 𝓩}
    {f : Fluxes} (hf : f ∈ F.reduce.toFluxesFive) :
    f ∈ (Multiset.powerset F.toFluxesFive).map fun s => s.sum := by𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩f:Fluxeshf:f ∈ F.reduce.toFluxesFive⊢ f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesFive)
  rw [toFluxesFive,𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩f:Fluxeshf:f ∈ Multiset.map Prod.snd F.reduce⊢ f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesFive)𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩f:Fluxeshf:∃ a ∈ F.reduce, a.2 = f⊢ f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesFive) Multiset.mem_map𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩f:Fluxeshf:∃ a ∈ F.reduce, a.2 = f⊢ f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesFive)𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩f:Fluxeshf:∃ a ∈ F.reduce, a.2 = f⊢ f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesFive)] at hf𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩f:Fluxeshf:∃ a ∈ F.reduce, a.2 = f⊢ f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesFive)
  obtain ⟨⟨q, f⟩, hp, rfl⟩ := hf𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩q:𝓩f:Fluxeshp:(q, f) ∈ F.reduce⊢ (q, f).2 ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesFive)
  rw [mem_reduce_iff𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩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.toFluxesFive)𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩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.toFluxesFive)] at hp𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩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.toFluxesFive)
  simp at hp𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩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.toFluxesFive)
  obtain ⟨hq, rfl⟩ := hp𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩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.toFluxesFive)
  simp only [Multiset.mem_map, Multiset.mem_powerset]𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩q:𝓩hq:q ∈ F.toCharges⊢ ∃ a ≤ F.toFluxesFive, 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:FiveQuanta 𝓩q:𝓩hq:q ∈ F.toCharges⊢ Multiset.map (fun x => x.2) (Multiset.filter (fun x => x.1 = q) F) ≤ F.toFluxesFive ∧
  (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
  exact ⟨Multiset.map_le_map (Multiset.filter_le _ F), rfl⟩All goals completed! 🐙



lemma mem_powerset_sum_of_mem_reduce_toFluxesFive_filter {F : FiveQuanta 𝓩}
    {f : Fluxes} (hf : f ∈ F.reduce.toFluxesFive) :
    f ∈ (F.toFluxesFive.powerset.filter fun s => s ≠ ∅).map fun s => s.sum := by𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩f:Fluxeshf:f ∈ F.reduce.toFluxesFive⊢ f ∈ Multiset.map (fun s => s.sum) (Multiset.filter (fun s => s ≠ ∅) (Multiset.powerset F.toFluxesFive))
  rw [toFluxesFive,𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩f:Fluxeshf:f ∈ Multiset.map Prod.snd F.reduce⊢ f ∈ Multiset.map (fun s => s.sum) (Multiset.filter (fun s => s ≠ ∅) (Multiset.powerset F.toFluxesFive))𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩f:Fluxeshf:∃ a ∈ F.reduce, a.2 = f⊢ f ∈ Multiset.map (fun s => s.sum) (Multiset.filter (fun s => s ≠ ∅) (Multiset.powerset F.toFluxesFive)) Multiset.mem_map𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩f:Fluxeshf:∃ a ∈ F.reduce, a.2 = f⊢ f ∈ Multiset.map (fun s => s.sum) (Multiset.filter (fun s => s ≠ ∅) (Multiset.powerset F.toFluxesFive))𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩f:Fluxeshf:∃ a ∈ F.reduce, a.2 = f⊢ f ∈ Multiset.map (fun s => s.sum) (Multiset.filter (fun s => s ≠ ∅) (Multiset.powerset F.toFluxesFive))] at hf𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩f:Fluxeshf:∃ a ∈ F.reduce, a.2 = f⊢ f ∈ Multiset.map (fun s => s.sum) (Multiset.filter (fun s => s ≠ ∅) (Multiset.powerset F.toFluxesFive))
  obtain ⟨⟨q, f⟩, hp, rfl⟩ := hf𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩q:𝓩f:Fluxeshp:(q, f) ∈ F.reduce⊢ (q, f).2 ∈ Multiset.map (fun s => s.sum) (Multiset.filter (fun s => s ≠ ∅) (Multiset.powerset F.toFluxesFive))
  rw [mem_reduce_iff𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩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 ≠ ∅) (Multiset.powerset F.toFluxesFive))𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩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 ≠ ∅) (Multiset.powerset F.toFluxesFive))] at hp𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩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 ≠ ∅) (Multiset.powerset F.toFluxesFive))
  simp at hp𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩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 ≠ ∅) (Multiset.powerset F.toFluxesFive))
  obtain ⟨hq, rfl⟩ := hp𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩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 ≠ ∅) (Multiset.powerset F.toFluxesFive))
  simp only [Multiset.mem_map]𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩q:𝓩hq:q ∈ F.toCharges⊢ ∃ a ∈ Multiset.filter (fun s => s ≠ ∅) (Multiset.powerset F.toFluxesFive),
  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:FiveQuanta 𝓩q:𝓩hq:q ∈ F.toCharges⊢ Multiset.map (fun x => x.2) (Multiset.filter (fun x => x.1 = q) F) ∈
    Multiset.filter (fun s => s ≠ ∅) (Multiset.powerset F.toFluxesFive) ∧
  (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:FiveQuanta 𝓩q:𝓩hq:q ∈ F.toCharges⊢ Multiset.map (fun x => x.2) (Multiset.filter (fun x => x.1 = q) F) ∈
  Multiset.filter (fun s => s ≠ ∅) (Multiset.powerset F.toFluxesFive)
  rw [Multiset.mem_filterh𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩q:𝓩hq:q ∈ F.toCharges⊢ Multiset.map (fun x => x.2) (Multiset.filter (fun x => x.1 = q) F) ∈ Multiset.powerset F.toFluxesFive ∧
  Multiset.map (fun x => x.2) (Multiset.filter (fun x => x.1 = q) F) ≠ ∅h𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩q:𝓩hq:q ∈ F.toCharges⊢ Multiset.map (fun x => x.2) (Multiset.filter (fun x => x.1 = q) F) ∈ Multiset.powerset F.toFluxesFive ∧
  Multiset.map (fun x => x.2) (Multiset.filter (fun x => x.1 = q) F) ≠ ∅]h𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩q:𝓩hq:q ∈ F.toCharges⊢ Multiset.map (fun x => x.2) (Multiset.filter (fun x => x.1 = q) F) ∈ Multiset.powerset F.toFluxesFive ∧
  Multiset.map (fun x => x.2) (Multiset.filter (fun x => x.1 = q) F) ≠ ∅
  apply And.introh.left𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩q:𝓩hq:q ∈ F.toCharges⊢ Multiset.map (fun x => x.2) (Multiset.filter (fun x => x.1 = q) F) ∈ Multiset.powerset F.toFluxesFiveh.right𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩q:𝓩hq:q ∈ F.toCharges⊢ Multiset.map (fun x => x.2) (Multiset.filter (fun x => x.1 = q) F) ≠ ∅
  exact Multiset.mem_powerset.mpr (Multiset.map_le_map (Multiset.filter_le (fun x => x.1 = q) F))h.right𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩q:𝓩hq:q ∈ F.toCharges⊢ Multiset.map (fun x => x.2) (Multiset.filter (fun x => x.1 = q) F) ≠ ∅
  simp [Multiset.empty_eq_zero, ne_eq, Multiset.map_eq_zero, Multiset.filter_eq_nil,
    Prod.forall, not_forall, Decidable.not_not]h.right𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩q:𝓩hq:q ∈ F.toCharges⊢ ∃ x, (q, x) ∈ F
  rw [toCharges,h.right𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩q:𝓩hq:q ∈ Multiset.map Prod.fst F⊢ ∃ x, (q, x) ∈ Fh.right𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩q:𝓩hq:∃ a ∈ F, a.1 = q⊢ ∃ x, (q, x) ∈ F Multiset.mem_maph.right𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩q:𝓩hq:∃ a ∈ F, a.1 = q⊢ ∃ x, (q, x) ∈ Fh.right𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩q:𝓩hq:∃ a ∈ F, a.1 = q⊢ ∃ x, (q, x) ∈ F] at hqh.right𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩q:𝓩hq:∃ a ∈ F, a.1 = q⊢ ∃ x, (q, x) ∈ F
  obtain ⟨a, ha, rfl⟩ := hqh.right𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩a:𝓩 × Fluxesha:a ∈ F⊢ ∃ x, (a.1, x) ∈ F
  use a.2All goals completed! 🐙

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

B.10.1. Number of chiral `L`



lemma reduce_numChiralL_of_mem_elemsNoExotics {F : FiveQuanta 𝓩}
    (hx : F.toFluxesFive ∈ FluxesFive.elemsNoExotics) :
    F.reduce.toFluxesFive.numChiralL = 3 := by𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ F.reduce.toFluxesFive.numChiralL = 3
  have hE : F.toFluxesFive.NoExotics := ((FluxesFive.noExotics_iff_mem_elemsNoExotics _).mpr hx).1𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExotics⊢ F.reduce.toFluxesFive.numChiralL = 3
  have hnn : ∀ a ∈ F.reduce.toFluxesFive.map (fun f => f.M + f.N), 0 ≤ a := by
    intro a ha𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticsa:ℤha:a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive⊢ 0 ≤ a𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive, 0 ≤ a⊢ F.reduce.toFluxesFive.numChiralL = 3
    obtain ⟨f, hf, rfl⟩ := Multiset.mem_map.mp ha𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticsf:Fluxeshf:f ∈ F.reduce.toFluxesFiveha:f.M + f.N ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive⊢ 0 ≤ f.M + f.N𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive, 0 ≤ a⊢ F.reduce.toFluxesFive.numChiralL = 3
    replace hf := mem_powerset_sum_of_mem_reduce_toFluxesFive hf𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticsf:Fluxesha:f.M + f.N ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFivehf:f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesFive)⊢ 0 ≤ f.M + f.N𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive, 0 ≤ a⊢ F.reduce.toFluxesFive.numChiralL = 3
    clear ha hE𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticsf:Fluxeshf:f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesFive)⊢ 0 ≤ f.M + f.N𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive, 0 ≤ a⊢ F.reduce.toFluxesFive.numChiralL = 3
    generalize F.toFluxesFive = G at *𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩f:FluxesG:FluxesFivehx:G ∈ FluxesFive.elemsNoExoticshf:f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset G)⊢ 0 ≤ f.M + f.N𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive, 0 ≤ a⊢ F.reduce.toFluxesFive.numChiralL = 3
    revert f𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩G:FluxesFivehx:G ∈ FluxesFive.elemsNoExotics⊢ ∀ f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset G), 0 ≤ f.M + f.N𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive, 0 ≤ a⊢ F.reduce.toFluxesFive.numChiralL = 3
    revert G𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩⊢ ∀ G ∈ FluxesFive.elemsNoExotics, ∀ f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset G), 0 ≤ f.M + f.N𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive, 0 ≤ a⊢ F.reduce.toFluxesFive.numChiralL = 3
    decide𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive, 0 ≤ a⊢ F.reduce.toFluxesFive.numChiralL = 3𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive, 0 ≤ a⊢ F.reduce.toFluxesFive.numChiralL = 3
  rw [FluxesFive.numChiralL,𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.filter (fun x => 0 ≤ x) F.reduce.toFluxesFive.chiralIndicesOfL).sum = 3𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.map ((fun f => f.M + f.N) ∘ Prod.snd) F.reduce).sum = (Multiset.map ((fun f => f.M + f.N) ∘ Prod.snd) F).sum FluxesFive.chiralIndicesOfL,𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.filter (fun x => 0 ≤ x) (Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive)).sum = 3𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.map ((fun f => f.M + f.N) ∘ Prod.snd) F.reduce).sum = (Multiset.map ((fun f => f.M + f.N) ∘ Prod.snd) F).sum Multiset.filter_eq_self.mpr hnn,𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive).sum = 3𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.map ((fun f => f.M + f.N) ∘ Prod.snd) F.reduce).sum = (Multiset.map ((fun f => f.M + f.N) ∘ Prod.snd) F).sum
    ← FluxesFive.chiralIndicesOfL_sum_eq_three_of_noExotics _ hE,𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive).sum = F.toFluxesFive.chiralIndicesOfL.sum𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.map ((fun f => f.M + f.N) ∘ Prod.snd) F.reduce).sum = (Multiset.map ((fun f => f.M + f.N) ∘ Prod.snd) F).sum FluxesFive.chiralIndicesOfL,𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive).sum = (Multiset.map (fun f => f.M + f.N) F.toFluxesFive).sum𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.map ((fun f => f.M + f.N) ∘ Prod.snd) F.reduce).sum = (Multiset.map ((fun f => f.M + f.N) ∘ Prod.snd) F).sum
    toFluxesFive,𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.map (fun f => f.M + f.N) (Multiset.map Prod.snd F.reduce)).sum =
  (Multiset.map (fun f => f.M + f.N) F.toFluxesFive).sum𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.map ((fun f => f.M + f.N) ∘ Prod.snd) F.reduce).sum = (Multiset.map ((fun f => f.M + f.N) ∘ Prod.snd) F).sum toFluxesFive,𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.map (fun f => f.M + f.N) (Multiset.map Prod.snd F.reduce)).sum =
  (Multiset.map (fun f => f.M + f.N) (Multiset.map Prod.snd F)).sum𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.map ((fun f => f.M + f.N) ∘ Prod.snd) F.reduce).sum = (Multiset.map ((fun f => f.M + f.N) ∘ Prod.snd) F).sum Multiset.map_map,𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.map ((fun f => f.M + f.N) ∘ Prod.snd) F.reduce).sum =
  (Multiset.map (fun f => f.M + f.N) (Multiset.map Prod.snd F)).sum𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.map ((fun f => f.M + f.N) ∘ Prod.snd) F.reduce).sum = (Multiset.map ((fun f => f.M + f.N) ∘ Prod.snd) F).sum Multiset.map_map𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.map ((fun f => f.M + f.N) ∘ Prod.snd) F.reduce).sum = (Multiset.map ((fun f => f.M + f.N) ∘ Prod.snd) F).sum𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.map ((fun f => f.M + f.N) ∘ Prod.snd) F.reduce).sum = (Multiset.map ((fun f => f.M + f.N) ∘ Prod.snd) F).sum]𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.map ((fun f => f.M + f.N) ∘ Prod.snd) F.reduce).sum = (Multiset.map ((fun f => f.M + f.N) ∘ Prod.snd) F).sum
  exact reduce_sum_eq_sum_toCharges F (fun _ =>
    ⟨⟨fun f => f.M + f.N, by𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive, 0 ≤ ax✝:𝓩⊢ Fluxes.M 0 + Fluxes.N 0 = 0 simpAll goals completed! 🐙⟩, fun x y => by𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive, 0 ≤ ax✝:𝓩x:Fluxesy:Fluxes⊢ { toFun := fun f => f.M + f.N, map_zero' := ⋯ }.toFun (x + y) =
  { toFun := fun f => f.M + f.N, map_zero' := ⋯ }.toFun x + { toFun := fun f => f.M + f.N, map_zero' := ⋯ }.toFun y simp [add_add_add_comm]All goals completed! 🐙⟩)

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



lemma reduce_numAntiChiralL_of_mem_elemsNoExotics {F : FiveQuanta 𝓩}
    (hx : F.toFluxesFive ∈ FluxesFive.elemsNoExotics) :
    F.reduce.toFluxesFive.numAntiChiralL = 0 := by𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ F.reduce.toFluxesFive.numAntiChiralL = 0
  rw [FluxesFive.numAntiChiralL,𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ (Multiset.filter (fun x => x < 0) F.reduce.toFluxesFive.chiralIndicesOfL).sum = 0𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ ∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive, ¬a < 0 FluxesFive.chiralIndicesOfL,𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ (Multiset.filter (fun x => x < 0) (Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive)).sum = 0𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ ∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive, ¬a < 0
    Multiset.filter_eq_nil.mpr ?_,𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ Multiset.sum 0 = 0𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ ∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive, ¬a < 0𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ ∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive, ¬a < 0 Multiset.sum_zero𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ 0 = 0𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ ∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive, ¬a < 0𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ ∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive, ¬a < 0]𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ ∀ a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive, ¬a < 0
  intro a ha𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticsa:ℤha:a ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive⊢ ¬a < 0
  obtain ⟨f, hf, rfl⟩ := Multiset.mem_map.mp ha𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticsf:Fluxeshf:f ∈ F.reduce.toFluxesFiveha:f.M + f.N ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFive⊢ ¬f.M + f.N < 0
  replace hf := mem_powerset_sum_of_mem_reduce_toFluxesFive hf𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticsf:Fluxesha:f.M + f.N ∈ Multiset.map (fun f => f.M + f.N) F.reduce.toFluxesFivehf:f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesFive)⊢ ¬f.M + f.N < 0
  clear ha𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticsf:Fluxeshf:f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesFive)⊢ ¬f.M + f.N < 0
  generalize F.toFluxesFive = G at *𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩f:FluxesG:FluxesFivehx:G ∈ FluxesFive.elemsNoExoticshf:f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset G)⊢ ¬f.M + f.N < 0
  revert f𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩G:FluxesFivehx:G ∈ FluxesFive.elemsNoExotics⊢ ∀ f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset G), ¬f.M + f.N < 0
  revert G𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩⊢ ∀ G ∈ FluxesFive.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 `D`



lemma reduce_numChiralD_of_mem_elemsNoExotics {F : FiveQuanta 𝓩}
    (hx : F.toFluxesFive ∈ FluxesFive.elemsNoExotics) :
    F.reduce.toFluxesFive.numChiralD = 3 := by𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ F.reduce.toFluxesFive.numChiralD = 3
  have hE : F.toFluxesFive.NoExotics := ((FluxesFive.noExotics_iff_mem_elemsNoExotics _).mpr hx).1𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExotics⊢ F.reduce.toFluxesFive.numChiralD = 3
  have hnn : ∀ a ∈ F.reduce.toFluxesFive.map (fun f => f.M), 0 ≤ a := by
    intro a ha𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticsa:ℤha:a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive⊢ 0 ≤ a𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive, 0 ≤ a⊢ F.reduce.toFluxesFive.numChiralD = 3
    obtain ⟨f, hf, rfl⟩ := Multiset.mem_map.mp ha𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticsf:Fluxeshf:f ∈ F.reduce.toFluxesFiveha:f.M ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive⊢ 0 ≤ f.M𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive, 0 ≤ a⊢ F.reduce.toFluxesFive.numChiralD = 3
    replace hf := mem_powerset_sum_of_mem_reduce_toFluxesFive hf𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticsf:Fluxesha:f.M ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFivehf:f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesFive)⊢ 0 ≤ f.M𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive, 0 ≤ a⊢ F.reduce.toFluxesFive.numChiralD = 3
    clear ha hE𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticsf:Fluxeshf:f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesFive)⊢ 0 ≤ f.M𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive, 0 ≤ a⊢ F.reduce.toFluxesFive.numChiralD = 3
    generalize F.toFluxesFive = G at *𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩f:FluxesG:FluxesFivehx:G ∈ FluxesFive.elemsNoExoticshf:f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset G)⊢ 0 ≤ f.M𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive, 0 ≤ a⊢ F.reduce.toFluxesFive.numChiralD = 3
    revert f𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩G:FluxesFivehx:G ∈ FluxesFive.elemsNoExotics⊢ ∀ f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset G), 0 ≤ f.M𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive, 0 ≤ a⊢ F.reduce.toFluxesFive.numChiralD = 3
    revert G𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩⊢ ∀ G ∈ FluxesFive.elemsNoExotics, ∀ f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset G), 0 ≤ f.M𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive, 0 ≤ a⊢ F.reduce.toFluxesFive.numChiralD = 3
    decide𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive, 0 ≤ a⊢ F.reduce.toFluxesFive.numChiralD = 3𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive, 0 ≤ a⊢ F.reduce.toFluxesFive.numChiralD = 3
  rw [FluxesFive.numChiralD,𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.filter (fun x => 0 ≤ x) F.reduce.toFluxesFive.chiralIndicesOfD).sum = 3𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.map ((fun f => f.M) ∘ Prod.snd) F.reduce).sum = (Multiset.map ((fun f => f.M) ∘ Prod.snd) F).sum FluxesFive.chiralIndicesOfD,𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.filter (fun x => 0 ≤ x) (Multiset.map (fun f => f.M) F.reduce.toFluxesFive)).sum = 3𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.map ((fun f => f.M) ∘ Prod.snd) F.reduce).sum = (Multiset.map ((fun f => f.M) ∘ Prod.snd) F).sum Multiset.filter_eq_self.mpr hnn,𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.map (fun f => f.M) F.reduce.toFluxesFive).sum = 3𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.map ((fun f => f.M) ∘ Prod.snd) F.reduce).sum = (Multiset.map ((fun f => f.M) ∘ Prod.snd) F).sum
    ← FluxesFive.chiralIndicesOfD_sum_eq_three_of_noExotics _ hE,𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.map (fun f => f.M) F.reduce.toFluxesFive).sum = F.toFluxesFive.chiralIndicesOfD.sum𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.map ((fun f => f.M) ∘ Prod.snd) F.reduce).sum = (Multiset.map ((fun f => f.M) ∘ Prod.snd) F).sum FluxesFive.chiralIndicesOfD,𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.map (fun f => f.M) F.reduce.toFluxesFive).sum = (Multiset.map (fun f => f.M) F.toFluxesFive).sum𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.map ((fun f => f.M) ∘ Prod.snd) F.reduce).sum = (Multiset.map ((fun f => f.M) ∘ Prod.snd) F).sum
    toFluxesFive,𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.map (fun f => f.M) (Multiset.map Prod.snd F.reduce)).sum = (Multiset.map (fun f => f.M) F.toFluxesFive).sum𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.map ((fun f => f.M) ∘ Prod.snd) F.reduce).sum = (Multiset.map ((fun f => f.M) ∘ Prod.snd) F).sum toFluxesFive,𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.map (fun f => f.M) (Multiset.map Prod.snd F.reduce)).sum =
  (Multiset.map (fun f => f.M) (Multiset.map Prod.snd F)).sum𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.map ((fun f => f.M) ∘ Prod.snd) F.reduce).sum = (Multiset.map ((fun f => f.M) ∘ Prod.snd) F).sum Multiset.map_map,𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.map ((fun f => f.M) ∘ Prod.snd) F.reduce).sum = (Multiset.map (fun f => f.M) (Multiset.map Prod.snd F)).sum𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.map ((fun f => f.M) ∘ Prod.snd) F.reduce).sum = (Multiset.map ((fun f => f.M) ∘ Prod.snd) F).sum Multiset.map_map𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.map ((fun f => f.M) ∘ Prod.snd) F.reduce).sum = (Multiset.map ((fun f => f.M) ∘ Prod.snd) F).sum𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.map ((fun f => f.M) ∘ Prod.snd) F.reduce).sum = (Multiset.map ((fun f => f.M) ∘ Prod.snd) F).sum]𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive, 0 ≤ a⊢ (Multiset.map ((fun f => f.M) ∘ Prod.snd) F.reduce).sum = (Multiset.map ((fun f => f.M) ∘ Prod.snd) F).sum
  exact reduce_sum_eq_sum_toCharges F (fun _ => ⟨⟨fun f => f.M, by𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive, 0 ≤ ax✝:𝓩⊢ Fluxes.M 0 = 0 simpAll goals completed! 🐙⟩, fun x y => by𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticshE:F.toFluxesFive.NoExoticshnn:∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive, 0 ≤ ax✝:𝓩x:Fluxesy:Fluxes⊢ { toFun := fun f => f.M, map_zero' := ⋯ }.toFun (x + y) =
  { toFun := fun f => f.M, map_zero' := ⋯ }.toFun x + { toFun := fun f => f.M, map_zero' := ⋯ }.toFun y simpAll goals completed! 🐙⟩)

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



lemma reduce_numAntiChiralD_of_mem_elemsNoExotics {F : FiveQuanta 𝓩}
    (hx : F.toFluxesFive ∈ FluxesFive.elemsNoExotics) :
    F.reduce.toFluxesFive.numAntiChiralD = 0 := by𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ F.reduce.toFluxesFive.numAntiChiralD = 0
  rw [FluxesFive.numAntiChiralD,𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ (Multiset.filter (fun x => x < 0) F.reduce.toFluxesFive.chiralIndicesOfD).sum = 0𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ ∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive, ¬a < 0 FluxesFive.chiralIndicesOfD,𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ (Multiset.filter (fun x => x < 0) (Multiset.map (fun f => f.M) F.reduce.toFluxesFive)).sum = 0𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ ∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive, ¬a < 0
    Multiset.filter_eq_nil.mpr ?_,𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ Multiset.sum 0 = 0𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ ∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive, ¬a < 0𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ ∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive, ¬a < 0 Multiset.sum_zero𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ 0 = 0𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ ∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive, ¬a < 0𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ ∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive, ¬a < 0]𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ ∀ a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive, ¬a < 0
  intro a ha𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticsa:ℤha:a ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive⊢ ¬a < 0
  obtain ⟨f, hf, rfl⟩ := Multiset.mem_map.mp ha𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticsf:Fluxeshf:f ∈ F.reduce.toFluxesFiveha:f.M ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFive⊢ ¬f.M < 0
  replace hf := mem_powerset_sum_of_mem_reduce_toFluxesFive hf𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticsf:Fluxesha:f.M ∈ Multiset.map (fun f => f.M) F.reduce.toFluxesFivehf:f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesFive)⊢ ¬f.M < 0
  clear ha𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExoticsf:Fluxeshf:f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset F.toFluxesFive)⊢ ¬f.M < 0
  generalize F.toFluxesFive = G at *𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩f:FluxesG:FluxesFivehx:G ∈ FluxesFive.elemsNoExoticshf:f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset G)⊢ ¬f.M < 0
  revert f𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩G:FluxesFivehx:G ∈ FluxesFive.elemsNoExotics⊢ ∀ f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset G), ¬f.M < 0
  revert G𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩⊢ ∀ G ∈ FluxesFive.elemsNoExotics, ∀ f ∈ Multiset.map (fun s => s.sum) (Multiset.powerset G), ¬f.M < 0
  decideAll goals completed! 🐙

B.10.5. The `NoExotics` condition on the reduced `FiveQuanta`

lemma reduce_noExotics_of_mem_elemsNoExotics {F : FiveQuanta 𝓩}
    (hx : F.toFluxesFive ∈ FluxesFive.elemsNoExotics) :
    F.reduce.toFluxesFive.NoExotics := by𝓩:Typeinst✝:DecidableEq 𝓩F:FiveQuanta 𝓩hx:F.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ F.reduce.toFluxesFive.NoExotics
  simp [FluxesFive.NoExotics, reduce_numChiralL_of_mem_elemsNoExotics hx,
    reduce_numAntiChiralL_of_mem_elemsNoExotics hx, reduce_numChiralD_of_mem_elemsNoExotics hx,
    reduce_numAntiChiralD_of_mem_elemsNoExotics hx]All goals completed! 🐙

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



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

C. Decomposition of a `FiveQuanta` into basic fluxes

C.1. Decomposition of fluxes

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

def decomposeFluxes (f : Fluxes) : Multiset Fluxes :=
  Multiset.replicate (Int.natAbs f.M) ⟨1, -1⟩ +
  Multiset.replicate (Int.natAbs (f.M + f.N)) ⟨0, 1⟩

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

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

The decomposition of a FiveQuanta into a FiveQuanta which has the same reduce by has fluxes ⟨1, -1⟩ and ⟨0,1⟩ only.

def decompose (x : FiveQuanta 𝓩) : FiveQuanta 𝓩 :=
  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 : FiveQuanta 𝓩) :
    (x + y).decompose = x.decompose + y.decompose := by𝓩:Typex:FiveQuanta 𝓩y:FiveQuanta 𝓩⊢ (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 : FiveQuanta 𝓩) (q : 𝓩) :
    (x.decompose).filter (fun p => p.1 = q) =
    decompose (x.filter (fun p => p.1 = q)) := by𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩q:𝓩⊢ Multiset.filter (fun p => p.1 = q) x.decompose = decompose (Multiset.filter (fun p => p.1 = q) x)
  rw [decompose𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩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:FiveQuanta 𝓩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:FiveQuanta 𝓩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 : FiveQuanta 𝓩),
  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)
    match a with
    | (q', f) =>𝓩: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)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]𝓩: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)q':𝓩f:Fluxes⊢ Multiset.filter (fun p => p.1 = q) (Multiset.replicate f.M.natAbs (q', { M := 1, N := -1 })) +
    Multiset.filter (fun p => p.1 = q) (Multiset.replicate (f.M + f.N).natAbs (q', { M := 0, N := 1 })) =
  decompose (if q' = q then {(q', f)} else 0)
    by_cases h : q' = qpos𝓩: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)q':𝓩f:Fluxesh:q' = q⊢ Multiset.filter (fun p => p.1 = q) (Multiset.replicate f.M.natAbs (q', { M := 1, N := -1 })) +
    Multiset.filter (fun p => p.1 = q) (Multiset.replicate (f.M + f.N).natAbs (q', { M := 0, N := 1 })) =
  decompose (if q' = q then {(q', f)} else 0)neg𝓩: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)q':𝓩f:Fluxesh:¬q' = q⊢ Multiset.filter (fun p => p.1 = q) (Multiset.replicate f.M.natAbs (q', { M := 1, N := -1 })) +
    Multiset.filter (fun p => p.1 = q) (Multiset.replicate (f.M + f.N).natAbs (q', { M := 0, N := 1 })) =
  decompose (if q' = q then {(q', f)} else 0)
    ·pos𝓩: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)q':𝓩f:Fluxesh:q' = q⊢ Multiset.filter (fun p => p.1 = q) (Multiset.replicate f.M.natAbs (q', { M := 1, N := -1 })) +
    Multiset.filter (fun p => p.1 = q) (Multiset.replicate (f.M + f.N).natAbs (q', { M := 0, N := 1 })) =
  decompose (if q' = q then {(q', f)} else 0) subst hpos𝓩:Typeinst✝:DecidableEq 𝓩a:𝓩 × Fluxesx: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.replicate f.M.natAbs (q', { M := 1, N := -1 })) +
    Multiset.filter (fun p => p.1 = q') (Multiset.replicate (f.M + f.N).natAbs (q', { M := 0, N := 1 })) =
  decompose (if q' = q' then {(q', f)} else 0)
      simp [decompose, decomposeFluxes]pos𝓩:Typeinst✝:DecidableEq 𝓩a:𝓩 × Fluxesx: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.replicate f.M.natAbs (q', { M := 1, N := -1 })) +
    Multiset.filter (fun p => p.1 = q') (Multiset.replicate (f.M + f.N).natAbs (q', { M := 0, N := 1 })) =
  Multiset.replicate f.M.natAbs (q', { M := 1, N := -1 }) +
    Multiset.replicate (f.M + f.N).natAbs (q', { M := 0, N := 1 })
      congrpos.e_a𝓩:Typeinst✝:DecidableEq 𝓩a:𝓩 × Fluxesx: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.replicate f.M.natAbs (q', { M := 1, N := -1 })) =
  Multiset.replicate f.M.natAbs (q', { M := 1, N := -1 })pos.e_a𝓩:Typeinst✝:DecidableEq 𝓩a:𝓩 × Fluxesx: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.replicate (f.M + f.N).natAbs (q', { M := 0, N := 1 })) =
  Multiset.replicate (f.M + f.N).natAbs (q', { M := 0, N := 1 })
      all_goals
      ·pos.e_a𝓩:Typeinst✝:DecidableEq 𝓩a:𝓩 × Fluxesx: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.replicate (f.M + f.N).natAbs (q', { M := 0, N := 1 })) =
  Multiset.replicate (f.M + f.N).natAbs (q', { M := 0, N := 1 }) refine Multiset.filter_eq_self.mpr ?_pos.e_a𝓩:Typeinst✝:DecidableEq 𝓩a:𝓩 × Fluxesx: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)⊢ ∀ a ∈ Multiset.replicate (f.M + f.N).natAbs (q', { M := 0, N := 1 }), a.1 = q'
        intro a hapos.e_a𝓩:Typeinst✝:DecidableEq 𝓩a✝:𝓩 × Fluxesx: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)a:𝓩 × Fluxesha:a ∈ Multiset.replicate (f.M + f.N).natAbs (q', { M := 0, N := 1 })⊢ a.1 = q'
        simp [Multiset.mem_replicate] at hapos.e_a𝓩:Typeinst✝:DecidableEq 𝓩a✝:𝓩 × Fluxesx: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)a:𝓩 × Fluxesha:¬f.M + f.N = 0 ∧ a = (q', { M := 0, N := 1 })⊢ a.1 = q'
        rw [ha.2pos.e_a𝓩:Typeinst✝:DecidableEq 𝓩a✝:𝓩 × Fluxesx: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)a:𝓩 × Fluxesha:¬f.M = 0 ∧ a = (q', { M := 1, N := -1 })⊢ (q', { M := 1, N := -1 }).1 = q'All goals completed! 🐙]All goals completed! 🐙
    ·neg𝓩: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)q':𝓩f:Fluxesh:¬q' = q⊢ Multiset.filter (fun p => p.1 = q) (Multiset.replicate f.M.natAbs (q', { M := 1, N := -1 })) +
    Multiset.filter (fun p => p.1 = q) (Multiset.replicate (f.M + f.N).natAbs (q', { M := 0, N := 1 })) =
  decompose (if q' = q then {(q', f)} else 0) simp [h, decompose]neg𝓩: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)q':𝓩f:Fluxesh:¬q' = q⊢ (∀ (a : 𝓩) (b : Fluxes), (a, b) ∈ Multiset.replicate f.M.natAbs (q', { M := 1, N := -1 }) → ¬a = q) ∧
  ∀ (a : 𝓩) (b : Fluxes), (a, b) ∈ Multiset.replicate (f.M + f.N).natAbs (q', { M := 0, N := 1 }) → ¬a = q
      apply And.introneg.left𝓩: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)q':𝓩f:Fluxesh:¬q' = q⊢ ∀ (a : 𝓩) (b : Fluxes), (a, b) ∈ Multiset.replicate f.M.natAbs (q', { M := 1, N := -1 }) → ¬a = qneg.right𝓩: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)q':𝓩f:Fluxesh:¬q' = q⊢ ∀ (a : 𝓩) (b : Fluxes), (a, b) ∈ Multiset.replicate (f.M + f.N).natAbs (q', { M := 0, N := 1 }) → ¬a = q
      all_goals
      ·neg.right𝓩: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)q':𝓩f:Fluxesh:¬q' = q⊢ ∀ (a : 𝓩) (b : Fluxes), (a, b) ∈ Multiset.replicate (f.M + f.N).natAbs (q', { M := 0, N := 1 }) → ¬a = q intro a b hneg.right𝓩: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)q':𝓩f:Fluxesh✝:¬q' = qa:𝓩b:Fluxesh:(a, b) ∈ Multiset.replicate (f.M + f.N).natAbs (q', { M := 0, N := 1 })⊢ ¬a = q
        simp [Multiset.mem_replicate] at hneg.right𝓩: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)q':𝓩f:Fluxesh✝:¬q' = qa:𝓩b:Fluxesh:¬f.M + f.N = 0 ∧ a = q' ∧ b = { M := 0, N := 1 }⊢ ¬a = q
        simp_allAll goals completed! 🐙

C.2.3. Decomposition preserves the charge map



lemma decompose_toChargeMap [DecidableEq 𝓩] (x : FiveQuanta 𝓩)
    (hx : x.toFluxesFive ∈ FluxesFive.elemsNoExotics) :
    x.decompose.toChargeMap = x.toChargeMap := by𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ x.decompose.toChargeMap = x.toChargeMap
  ext q𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExoticsq:𝓩⊢ x.decompose.toChargeMap q = x.toChargeMap q
  rw [toChargeMap,𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExoticsq:𝓩⊢ (Multiset.map Prod.snd (Multiset.filter (fun p => p.1 = q) x.decompose)).sum = x.toChargeMap q𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExoticsq:𝓩⊢ (Multiset.map Prod.snd (decompose (Multiset.filter (fun p => p.1 = q) x))).sum = x.toChargeMap q decompose_filter_charge𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExoticsq:𝓩⊢ (Multiset.map Prod.snd (decompose (Multiset.filter (fun p => p.1 = q) x))).sum = x.toChargeMap q𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExoticsq:𝓩⊢ (Multiset.map Prod.snd (decompose (Multiset.filter (fun p => p.1 = q) x))).sum = x.toChargeMap q]𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExoticsq:𝓩⊢ (Multiset.map Prod.snd (decompose (Multiset.filter (fun p => p.1 = q) x))).sum = x.toChargeMap q
  simp [decompose]𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.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:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.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:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.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:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.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:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.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:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.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:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.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:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.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:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.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)
  apply Multiset.map_congra𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExoticsq:𝓩⊢ Multiset.filter (fun p => p.1 = q) x = Multiset.filter (fun p => p.1 = q) xa𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExoticsq:𝓩⊢ ∀ x_1 ∈ Multiset.filter (fun p => p.1 = q) x, (decomposeFluxes x_1.2).sum = x_1.2
  ·a𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExoticsq:𝓩⊢ Multiset.filter (fun p => p.1 = q) x = Multiset.filter (fun p => p.1 = q) x rflAll goals completed! 🐙
  intro a haa𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExoticsq:𝓩a:𝓩 × Fluxesha:a ∈ Multiset.filter (fun p => p.1 = q) x⊢ (decomposeFluxes a.2).sum = a.2
  exact decomposeFluxes_sum_of_noExotics a.2
    ⟨x.toFluxesFive, hx, Multiset.mem_map_of_mem Prod.snd (Multiset.mem_filter.mp ha).1⟩All goals completed! 🐙

C.2.4. Decomposition preserves the charges



lemma decompose_toCharges_dedup [DecidableEq 𝓩] (x : FiveQuanta 𝓩)
    (hx : x.toFluxesFive ∈ FluxesFive.elemsNoExotics) :
    x.decompose.toCharges.dedup = x.toCharges.dedup := by𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ x.decompose.toCharges.dedup = x.toCharges.dedup
  refine Multiset.dedup_ext.mpr ?_𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ ∀ (a : 𝓩), a ∈ x.decompose.toCharges ↔ a ∈ x.toCharges
  intro q𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExoticsq:𝓩⊢ q ∈ x.decompose.toCharges ↔ q ∈ x.toCharges
  simp [decompose, toCharges, -existsAndEq]𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExoticsq:𝓩⊢ (∃ x_1 a b, (a, b) ∈ x ∧ x_1 ∈ decomposeFluxes b ∧ a = q) ↔ ∃ x_1, (q, x_1) ∈ x
  constructormp𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExoticsq:𝓩⊢ (∃ x_1 a b, (a, b) ∈ x ∧ x_1 ∈ decomposeFluxes b ∧ a = q) → ∃ x_1, (q, x_1) ∈ xmpr𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExoticsq:𝓩⊢ (∃ x_1, (q, x_1) ∈ x) → ∃ x_1 a b, (a, b) ∈ x ∧ x_1 ∈ decomposeFluxes b ∧ a = q
  ·mp𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.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:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.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:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.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:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.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:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ x.decompose.toCharges.dedup = x.toCharges.dedupmpr𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.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.toFluxesFive := by𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ x.decompose.toCharges.dedup = x.toCharges.dedup𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExoticsq:𝓩c:Fluxesh1:(q, c) ∈ xc_mem_f:c ∈ x.toFluxesFive⊢ decomposeFluxes c ≠ 0mpr𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExoticsq:𝓩c:Fluxesh1:(q, c) ∈ xhn:decomposeFluxes c ≠ 0⊢ ∃ x_1 a b, (a, b) ∈ x ∧ x_1 ∈ decomposeFluxes b ∧ a = q
        simp [toFluxesFive]𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExoticsq:𝓩c:Fluxesh1:(q, c) ∈ x⊢ ∃ a, (a, c) ∈ x𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExoticsq:𝓩c:Fluxesh1:(q, c) ∈ xc_mem_f:c ∈ x.toFluxesFive⊢ decomposeFluxes c ≠ 0mpr𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.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:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExoticsq:𝓩c:Fluxesh1:(q, c) ∈ xc_mem_f:c ∈ x.toFluxesFive⊢ decomposeFluxes c ≠ 0mpr𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.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:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExoticsq:𝓩c:Fluxesh1:(q, c) ∈ xc_mem_f:c ∈ x.toFluxesFive⊢ decomposeFluxes c ≠ 0mpr𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExoticsq:𝓩c:Fluxesh1:(q, c) ∈ xhn:decomposeFluxes c ≠ 0⊢ ∃ x_1 a b, (a, b) ∈ x ∧ x_1 ∈ decomposeFluxes b ∧ a = q
      generalize x.toFluxesFive = F at *𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩q:𝓩c:Fluxesh1:(q, c) ∈ xF:FluxesFivehx:F ∈ FluxesFive.elemsNoExoticsc_mem_f:c ∈ F⊢ decomposeFluxes c ≠ 0mpr𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.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:FiveQuanta 𝓩q:𝓩c:FluxesF:FluxesFivehx:F ∈ FluxesFive.elemsNoExoticsc_mem_f:c ∈ F⊢ decomposeFluxes c ≠ 0mpr𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.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:FiveQuanta 𝓩q:𝓩F:FluxesFivehx:F ∈ FluxesFive.elemsNoExotics⊢ ∀ c ∈ F, decomposeFluxes c ≠ 0mpr𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.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:FiveQuanta 𝓩q:𝓩⊢ ∀ F ∈ FluxesFive.elemsNoExotics, ∀ c ∈ F, decomposeFluxes c ≠ 0mpr𝓩:Typeinst✝:DecidableEq 𝓩x:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.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:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.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:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.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:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.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:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.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 : FiveQuanta 𝓩) [DecidableEq 𝓩]
    (hx : x.toFluxesFive ∈ FluxesFive.elemsNoExotics) :
    x.decompose.reduce = x.reduce := by𝓩:Typex:FiveQuanta 𝓩inst✝:DecidableEq 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ x.decompose.reduce = x.reduce
  rw [reduce,𝓩:Typex:FiveQuanta 𝓩inst✝:DecidableEq 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ Multiset.map (fun q5 => (q5, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q5) x.decompose)).sum))
    x.decompose.toCharges.dedup =
  x.reduce𝓩:Typex:FiveQuanta 𝓩inst✝:DecidableEq 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ Multiset.map (fun q5 => (q5, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q5) x.decompose)).sum))
    x.decompose.toCharges.dedup =
  Multiset.map (fun q5 => (q5, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q5) x)).sum))
    x.toCharges.dedup reduce𝓩:Typex:FiveQuanta 𝓩inst✝:DecidableEq 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ Multiset.map (fun q5 => (q5, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q5) x.decompose)).sum))
    x.decompose.toCharges.dedup =
  Multiset.map (fun q5 => (q5, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q5) x)).sum))
    x.toCharges.dedup𝓩:Typex:FiveQuanta 𝓩inst✝:DecidableEq 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ Multiset.map (fun q5 => (q5, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q5) x.decompose)).sum))
    x.decompose.toCharges.dedup =
  Multiset.map (fun q5 => (q5, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q5) x)).sum))
    x.toCharges.dedup]𝓩:Typex:FiveQuanta 𝓩inst✝:DecidableEq 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ Multiset.map (fun q5 => (q5, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q5) x.decompose)).sum))
    x.decompose.toCharges.dedup =
  Multiset.map (fun q5 => (q5, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = q5) x)).sum))
    x.toCharges.dedup
  apply Multiset.map_congra𝓩:Typex:FiveQuanta 𝓩inst✝:DecidableEq 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ x.decompose.toCharges.dedup = x.toCharges.dedupa𝓩:Typex:FiveQuanta 𝓩inst✝:DecidableEq 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ ∀ x_1 ∈ x.toCharges.dedup,
  (x_1, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = x_1) x.decompose)).sum) =
    (x_1, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = x_1) x)).sum)
  ·a𝓩:Typex:FiveQuanta 𝓩inst✝:DecidableEq 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ x.decompose.toCharges.dedup = x.toCharges.dedup rw [decompose_toCharges_dedup x hxa𝓩:Typex:FiveQuanta 𝓩inst✝:DecidableEq 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ x.toCharges.dedup = x.toCharges.dedupAll goals completed! 🐙]All goals completed! 🐙
  ·a𝓩:Typex:FiveQuanta 𝓩inst✝:DecidableEq 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ ∀ x_1 ∈ x.toCharges.dedup,
  (x_1, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = x_1) x.decompose)).sum) =
    (x_1, (Multiset.map (fun y => y.2) (Multiset.filter (fun f => f.1 = x_1) x)).sum) intro q hx'a𝓩:Typex:FiveQuanta 𝓩inst✝:DecidableEq 𝓩hx:x.toFluxesFive ∈ FluxesFive.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]a𝓩:Typex:FiveQuanta 𝓩inst✝:DecidableEq 𝓩hx:x.toFluxesFive ∈ FluxesFive.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
    exact congrFun (decompose_toChargeMap x hx) qAll goals completed! 🐙

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



lemma decompose_toFluxesFive (x : FiveQuanta 𝓩)
    (hx : x.toFluxesFive ∈ FluxesFive.elemsNoExotics) :
    x.decompose.toFluxesFive = {⟨1, -1⟩, ⟨1, -1⟩, ⟨1, -1⟩, ⟨0, 1⟩, ⟨0, 1⟩, ⟨0, 1⟩} := by𝓩:Typex:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ x.decompose.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}
  rw [toFluxesFive,𝓩:Typex:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ Multiset.map Prod.snd x.decompose =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}𝓩:Typex:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ 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 := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }} decompose𝓩:Typex:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ 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 := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}𝓩:Typex:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ 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 := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}]𝓩:Typex:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ 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 := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}
  rw [Multiset.map_bind𝓩:Typex:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ (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 := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}𝓩:Typex:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ (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 := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}]𝓩:Typex:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ (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 := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}
  simp only [Multiset.map_map, Function.comp_apply, Multiset.map_id', Int.reduceNeg,
    Multiset.insert_eq_cons]𝓩:Typex:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ (Multiset.bind x fun a => decomposeFluxes a.2) =
  { M := 1, N := -1 } ::ₘ
    { M := 1, N := -1 } ::ₘ { M := 1, N := -1 } ::ₘ { M := 0, N := 1 } ::ₘ { M := 0, N := 1 } ::ₘ {{ M := 0, N := 1 }}
  trans (Multiset.bind x.toFluxesFive fun a => decomposeFluxes a)𝓩:Typex:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ (Multiset.bind x fun a => decomposeFluxes a.2) = Multiset.bind x.toFluxesFive fun a => decomposeFluxes a𝓩:Typex:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ (Multiset.bind x.toFluxesFive fun a => decomposeFluxes a) =
  { M := 1, N := -1 } ::ₘ
    { M := 1, N := -1 } ::ₘ { M := 1, N := -1 } ::ₘ { M := 0, N := 1 } ::ₘ { M := 0, N := 1 } ::ₘ {{ M := 0, N := 1 }}
  ·𝓩:Typex:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ (Multiset.bind x fun a => decomposeFluxes a.2) = Multiset.bind x.toFluxesFive fun a => decomposeFluxes a rw [toFluxesFive,𝓩:Typex:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ (Multiset.bind x fun a => decomposeFluxes a.2) = (Multiset.map Prod.snd x).bind fun a => decomposeFluxes aAll goals completed! 🐙 Multiset.bind_map𝓩:Typex:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ (Multiset.bind x fun a => decomposeFluxes a.2) = Multiset.bind x fun a => decomposeFluxes a.2All goals completed! 🐙]All goals completed! 🐙
  ·𝓩:Typex:FiveQuanta 𝓩hx:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ (Multiset.bind x.toFluxesFive fun a => decomposeFluxes a) =
  { M := 1, N := -1 } ::ₘ
    { M := 1, N := -1 } ::ₘ { M := 1, N := -1 } ::ₘ { M := 0, N := 1 } ::ₘ { M := 0, N := 1 } ::ₘ {{ M := 0, N := 1 }} generalize x.toFluxesFive = F at *𝓩:Typex:FiveQuanta 𝓩F:FluxesFivehx:F ∈ FluxesFive.elemsNoExotics⊢ (Multiset.bind F fun a => decomposeFluxes a) =
  { M := 1, N := -1 } ::ₘ
    { M := 1, N := -1 } ::ₘ { M := 1, N := -1 } ::ₘ { M := 0, N := 1 } ::ₘ { M := 0, N := 1 } ::ₘ {{ M := 0, N := 1 }}
    revert F𝓩:Typex:FiveQuanta 𝓩⊢ ∀ F ∈ FluxesFive.elemsNoExotics,
  (Multiset.bind F fun a => decomposeFluxes a) =
    { M := 1, N := -1 } ::ₘ
      { M := 1, N := -1 } ::ₘ { M := 1, N := -1 } ::ₘ { M := 0, N := 1 } ::ₘ { M := 0, N := 1 } ::ₘ {{ M := 0, N := 1 }}
    decideAll goals completed! 🐙

D. Lifting charges to `FiveQuanta`

D.1. `liftCharge c`: multiset of five-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 FiveQuanta which do not have exotics, duplicate charges or zero fluxes, which map down to c.

def liftCharge (c : Finset 𝓩) : Multiset (FiveQuanta 𝓩) :=
  /- The multisets of cardinality 3 containing 3 elements of `c`. -/
  let S53 : Multiset (Multiset 𝓩) := toMultisetsThree c
  /- Pairs of multisets (s1, s2) such that s1 and s2 are cardinality of `3` containing
    elements of `c` and that all elements of `c` are in `s1 + s2`. -/
  let S5p : Multiset (Multiset 𝓩 × Multiset 𝓩) :=
    (S53 ×ˢ S53).filter fun (s1, s2) => c.val ≤ s1 + s2
  let Fp : Multiset (FiveQuanta 𝓩) :=
    S5p.map (fun y => y.1.map (fun z => (z, ⟨1, -1⟩)) + y.2.map (fun z => (z, ⟨0, 1⟩)))
  Fp.map reduce

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



lemma toCharges_toFinset_of_mem_liftCharge (c : Finset 𝓩) {x : FiveQuanta 𝓩}
    (h : x ∈ liftCharge c) : x.toCharges.toFinset = c := by𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x ∈ liftCharge c⊢ x.toCharges.toFinset = c
  simp [liftCharge] at h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:∃ a b,
  (((a.toFinset ⊆ c ∧ a.card = 3) ∧ b.toFinset ⊆ c ∧ b.card = 3) ∧ c.val ≤ a + b) ∧
    (Multiset.map (fun z => (z, { M := 1, N := -1 })) a + Multiset.map (fun z => (z, { M := 0, N := 1 })) b).reduce = x⊢ x.toCharges.toFinset = c
  obtain ⟨s1, s2, ⟨⟨⟨s1_subset, s1_card⟩, ⟨s2_subset, s2_card⟩⟩, hsum⟩, rfl⟩ := h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩s1:Multiset 𝓩s2:Multiset 𝓩hsum:c.val ≤ s1 + s2s1_subset:s1.toFinset ⊆ cs1_card:s1.card = 3s2_subset:s2.toFinset ⊆ cs2_card:s2.card = 3⊢ (Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 +
          Multiset.map (fun z => (z, { M := 0, N := 1 })) s2).reduce.toCharges.toFinset =
  c
  rw [← Multiset.toFinset_dedup,𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩s1:Multiset 𝓩s2:Multiset 𝓩hsum:c.val ≤ s1 + s2s1_subset:s1.toFinset ⊆ cs1_card:s1.card = 3s2_subset:s2.toFinset ⊆ cs2_card:s2.card = 3⊢ (Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 +
            Multiset.map (fun z => (z, { M := 0, N := 1 })) s2).reduce.toCharges.dedup.toFinset =
  c𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩s1:Multiset 𝓩s2:Multiset 𝓩hsum:c.val ≤ s1 + s2s1_subset:s1.toFinset ⊆ cs1_card:s1.card = 3s2_subset:s2.toFinset ⊆ cs2_card:s2.card = 3⊢ (Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 +
            Multiset.map (fun z => (z, { M := 0, N := 1 })) s2).toCharges.dedup.dedup.toFinset =
  c reduce_toCharges𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩s1:Multiset 𝓩s2:Multiset 𝓩hsum:c.val ≤ s1 + s2s1_subset:s1.toFinset ⊆ cs1_card:s1.card = 3s2_subset:s2.toFinset ⊆ cs2_card:s2.card = 3⊢ (Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 +
            Multiset.map (fun z => (z, { M := 0, N := 1 })) s2).toCharges.dedup.dedup.toFinset =
  c𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩s1:Multiset 𝓩s2:Multiset 𝓩hsum:c.val ≤ s1 + s2s1_subset:s1.toFinset ⊆ cs1_card:s1.card = 3s2_subset:s2.toFinset ⊆ cs2_card:s2.card = 3⊢ (Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 +
            Multiset.map (fun z => (z, { M := 0, N := 1 })) s2).toCharges.dedup.dedup.toFinset =
  c]𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩s1:Multiset 𝓩s2:Multiset 𝓩hsum:c.val ≤ s1 + s2s1_subset:s1.toFinset ⊆ cs1_card:s1.card = 3s2_subset:s2.toFinset ⊆ cs2_card:s2.card = 3⊢ (Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 +
            Multiset.map (fun z => (z, { M := 0, N := 1 })) s2).toCharges.dedup.dedup.toFinset =
  c
  simp only [Int.reduceNeg, Multiset.dedup_idem, Multiset.toFinset_dedup]𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩s1:Multiset 𝓩s2:Multiset 𝓩hsum:c.val ≤ s1 + s2s1_subset:s1.toFinset ⊆ cs1_card:s1.card = 3s2_subset:s2.toFinset ⊆ cs2_card:s2.card = 3⊢ (Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 +
        Multiset.map (fun z => (z, { M := 0, N := 1 })) s2).toCharges.toFinset =
  c
  simp [toCharges]𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩s1:Multiset 𝓩s2:Multiset 𝓩hsum:c.val ≤ s1 + s2s1_subset:s1.toFinset ⊆ cs1_card:s1.card = 3s2_subset:s2.toFinset ⊆ cs2_card:s2.card = 3⊢ s1.toFinset ∪ s2.toFinset = c
  refine Finset.Subset.antisymm (Finset.union_subset s1_subset s2_subset) fun a ha => ?_𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩s1:Multiset 𝓩s2:Multiset 𝓩hsum:c.val ≤ s1 + s2s1_subset:s1.toFinset ⊆ cs1_card:s1.card = 3s2_subset:s2.toFinset ⊆ cs2_card:s2.card = 3a:𝓩ha:a ∈ c⊢ a ∈ s1.toFinset ∪ s2.toFinset
  simpa using Multiset.mem_of_le hsum haAll goals completed! 🐙

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



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

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

              

lemma exists_toCharges_toFluxesFive_of_mem_liftCharge (c : Finset 𝓩) {x : FiveQuanta 𝓩}
    (h : x ∈ liftCharge c) :
    ∃ a : FiveQuanta 𝓩, a.reduce = x ∧ a.toCharges.toFinset = c ∧ a.toFluxesFive =
      {⟨1, -1⟩, ⟨1, -1⟩, ⟨1, -1⟩, ⟨0, 1⟩, ⟨0, 1⟩, ⟨0, 1⟩} := by𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x ∈ liftCharge c⊢ ∃ a,
  a.reduce = x ∧
    a.toCharges.toFinset = c ∧
      a.toFluxesFive =
        {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
          { M := 0, N := 1 }}
  have h' := h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x ∈ liftCharge ch':x ∈ liftCharge c⊢ ∃ a,
  a.reduce = x ∧
    a.toCharges.toFinset = c ∧
      a.toFluxesFive =
        {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
          { M := 0, N := 1 }}
  rw [liftCharge,𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x ∈
  Multiset.map reduce
    (Multiset.map
      (fun y =>
        Multiset.map (fun z => (z, { M := 1, N := -1 })) y.1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) y.2)
      (Multiset.filter
        (fun x =>
          match x with
          | (s1, s2) => c.val ≤ s1 + s2)
        (toMultisetsThree c ×ˢ toMultisetsThree c)))h':x ∈ liftCharge c⊢ ∃ a,
  a.reduce = x ∧
    a.toCharges.toFinset = c ∧
      a.toFluxesFive =
        {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
          { M := 0, N := 1 }}𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:∃
  a ∈
    Multiset.map
      (fun y =>
        Multiset.map (fun z => (z, { M := 1, N := -1 })) y.1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) y.2)
      (Multiset.filter
        (fun x =>
          match x with
          | (s1, s2) => c.val ≤ s1 + s2)
        (toMultisetsThree c ×ˢ toMultisetsThree c)),
  a.reduce = xh':x ∈ liftCharge c⊢ ∃ a,
  a.reduce = x ∧
    a.toCharges.toFinset = c ∧
      a.toFluxesFive =
        {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
          { M := 0, N := 1 }} Multiset.mem_map𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:∃
  a ∈
    Multiset.map
      (fun y =>
        Multiset.map (fun z => (z, { M := 1, N := -1 })) y.1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) y.2)
      (Multiset.filter
        (fun x =>
          match x with
          | (s1, s2) => c.val ≤ s1 + s2)
        (toMultisetsThree c ×ˢ toMultisetsThree c)),
  a.reduce = xh':x ∈ liftCharge c⊢ ∃ a,
  a.reduce = x ∧
    a.toCharges.toFinset = c ∧
      a.toFluxesFive =
        {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
          { M := 0, N := 1 }}𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:∃
  a ∈
    Multiset.map
      (fun y =>
        Multiset.map (fun z => (z, { M := 1, N := -1 })) y.1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) y.2)
      (Multiset.filter
        (fun x =>
          match x with
          | (s1, s2) => c.val ≤ s1 + s2)
        (toMultisetsThree c ×ˢ toMultisetsThree c)),
  a.reduce = xh':x ∈ liftCharge c⊢ ∃ a,
  a.reduce = x ∧
    a.toCharges.toFinset = c ∧
      a.toFluxesFive =
        {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
          { M := 0, N := 1 }}] at h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:∃
  a ∈
    Multiset.map
      (fun y =>
        Multiset.map (fun z => (z, { M := 1, N := -1 })) y.1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) y.2)
      (Multiset.filter
        (fun x =>
          match x with
          | (s1, s2) => c.val ≤ s1 + s2)
        (toMultisetsThree c ×ˢ toMultisetsThree c)),
  a.reduce = xh':x ∈ liftCharge c⊢ ∃ a,
  a.reduce = x ∧
    a.toCharges.toFinset = c ∧
      a.toFluxesFive =
        {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
          { M := 0, N := 1 }}
  obtain ⟨a, h, rfl⟩ := h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩a:FiveQuanta 𝓩h:a ∈
  Multiset.map
    (fun y =>
      Multiset.map (fun z => (z, { M := 1, N := -1 })) y.1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) y.2)
    (Multiset.filter
      (fun x =>
        match x with
        | (s1, s2) => c.val ≤ s1 + s2)
      (toMultisetsThree c ×ˢ toMultisetsThree c))h':a.reduce ∈ liftCharge c⊢ ∃ a_1,
  a_1.reduce = a.reduce ∧
    a_1.toCharges.toFinset = c ∧
      a_1.toFluxesFive =
        {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
          { M := 0, N := 1 }}
  use ah𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩a:FiveQuanta 𝓩h:a ∈
  Multiset.map
    (fun y =>
      Multiset.map (fun z => (z, { M := 1, N := -1 })) y.1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) y.2)
    (Multiset.filter
      (fun x =>
        match x with
        | (s1, s2) => c.val ≤ s1 + s2)
      (toMultisetsThree c ×ˢ toMultisetsThree c))h':a.reduce ∈ liftCharge c⊢ a.reduce = a.reduce ∧
  a.toCharges.toFinset = c ∧
    a.toFluxesFive =
      {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
        { M := 0, N := 1 }}
  simp only [Int.reduceNeg, Multiset.insert_eq_cons, true_and]h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩a:FiveQuanta 𝓩h:a ∈
  Multiset.map
    (fun y =>
      Multiset.map (fun z => (z, { M := 1, N := -1 })) y.1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) y.2)
    (Multiset.filter
      (fun x =>
        match x with
        | (s1, s2) => c.val ≤ s1 + s2)
      (toMultisetsThree c ×ˢ toMultisetsThree c))h':a.reduce ∈ liftCharge c⊢ a.toCharges.toFinset = c ∧
  a.toFluxesFive =
    { M := 1, N := -1 } ::ₘ
      { M := 1, N := -1 } ::ₘ { M := 1, N := -1 } ::ₘ { M := 0, N := 1 } ::ₘ { M := 0, N := 1 } ::ₘ {{ M := 0, N := 1 }}
  apply And.introh.left𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩a:FiveQuanta 𝓩h:a ∈
  Multiset.map
    (fun y =>
      Multiset.map (fun z => (z, { M := 1, N := -1 })) y.1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) y.2)
    (Multiset.filter
      (fun x =>
        match x with
        | (s1, s2) => c.val ≤ s1 + s2)
      (toMultisetsThree c ×ˢ toMultisetsThree c))h':a.reduce ∈ liftCharge c⊢ a.toCharges.toFinset = ch.right𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩a:FiveQuanta 𝓩h:a ∈
  Multiset.map
    (fun y =>
      Multiset.map (fun z => (z, { M := 1, N := -1 })) y.1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) y.2)
    (Multiset.filter
      (fun x =>
        match x with
        | (s1, s2) => c.val ≤ s1 + s2)
      (toMultisetsThree c ×ˢ toMultisetsThree c))h':a.reduce ∈ liftCharge c⊢ a.toFluxesFive =
  { M := 1, N := -1 } ::ₘ
    { M := 1, N := -1 } ::ₘ { M := 1, N := -1 } ::ₘ { M := 0, N := 1 } ::ₘ { M := 0, N := 1 } ::ₘ {{ M := 0, N := 1 }}
  ·h.left𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩a:FiveQuanta 𝓩h:a ∈
  Multiset.map
    (fun y =>
      Multiset.map (fun z => (z, { M := 1, N := -1 })) y.1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) y.2)
    (Multiset.filter
      (fun x =>
        match x with
        | (s1, s2) => c.val ≤ s1 + s2)
      (toMultisetsThree c ×ˢ toMultisetsThree c))h':a.reduce ∈ liftCharge c⊢ a.toCharges.toFinset = c simpa [reduce_toCharges] using toCharges_toFinset_of_mem_liftCharge c h'All goals completed! 🐙
  ·h.right𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩a:FiveQuanta 𝓩h:a ∈
  Multiset.map
    (fun y =>
      Multiset.map (fun z => (z, { M := 1, N := -1 })) y.1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) y.2)
    (Multiset.filter
      (fun x =>
        match x with
        | (s1, s2) => c.val ≤ s1 + s2)
      (toMultisetsThree c ×ˢ toMultisetsThree c))h':a.reduce ∈ liftCharge c⊢ a.toFluxesFive =
  { M := 1, N := -1 } ::ₘ
    { M := 1, N := -1 } ::ₘ { M := 1, N := -1 } ::ₘ { M := 0, N := 1 } ::ₘ { M := 0, N := 1 } ::ₘ {{ M := 0, N := 1 }} simp at hh.right𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩a:FiveQuanta 𝓩h':a.reduce ∈ liftCharge ch:∃ a_1 b,
  (((a_1.toFinset ⊆ c ∧ a_1.card = 3) ∧ b.toFinset ⊆ c ∧ b.card = 3) ∧ c.val ≤ a_1 + b) ∧
    Multiset.map (fun z => (z, { M := 1, N := -1 })) a_1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) b = a⊢ a.toFluxesFive =
  { M := 1, N := -1 } ::ₘ
    { M := 1, N := -1 } ::ₘ { M := 1, N := -1 } ::ₘ { M := 0, N := 1 } ::ₘ { M := 0, N := 1 } ::ₘ {{ M := 0, N := 1 }}
    obtain ⟨s1, s2, ⟨⟨⟨s1_subset, s1_card⟩, ⟨s2_subset, s2_card⟩⟩, hsum⟩, rfl⟩ := hh.right𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩s1:Multiset 𝓩s2:Multiset 𝓩hsum:c.val ≤ s1 + s2s1_subset:s1.toFinset ⊆ cs1_card:s1.card = 3s2_subset:s2.toFinset ⊆ cs2_card:s2.card = 3h':(Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) s2).reduce ∈
  liftCharge c⊢ (Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 +
      Multiset.map (fun z => (z, { M := 0, N := 1 })) s2).toFluxesFive =
  { M := 1, N := -1 } ::ₘ
    { M := 1, N := -1 } ::ₘ { M := 1, N := -1 } ::ₘ { M := 0, N := 1 } ::ₘ { M := 0, N := 1 } ::ₘ {{ M := 0, N := 1 }}
    simp [toFluxesFive, s1_card, s2_card]h.right𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩s1:Multiset 𝓩s2:Multiset 𝓩hsum:c.val ≤ s1 + s2s1_subset:s1.toFinset ⊆ cs1_card:s1.card = 3s2_subset:s2.toFinset ⊆ cs2_card:s2.card = 3h':(Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) s2).reduce ∈
  liftCharge c⊢ { M := 0, N := 1 } ::ₘ
    { M := 0, N := 1 } ::ₘ
      { M := 1, N := -1 } ::ₘ { M := 1, N := -1 } ::ₘ { M := 1, N := -1 } ::ₘ {{ M := 0, N := 1 }} =
  { M := 1, N := -1 } ::ₘ
    { M := 1, N := -1 } ::ₘ { M := 1, N := -1 } ::ₘ { M := 0, N := 1 } ::ₘ { M := 0, N := 1 } ::ₘ {{ M := 0, N := 1 }}
    decideAll goals completed! 🐙

lemma mem_liftCharge_of_exists_toCharges_toFluxesFive (c : Finset 𝓩) {x : FiveQuanta 𝓩}
    (h : ∃ a : FiveQuanta 𝓩, a.reduce = x ∧ a.toCharges.toFinset = c ∧ a.toFluxesFive =
      {⟨1, -1⟩, ⟨1, -1⟩, ⟨1, -1⟩, ⟨0, 1⟩, ⟨0, 1⟩, ⟨0, 1⟩}) :
    x ∈ liftCharge c := by𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:∃ a,
  a.reduce = x ∧
    a.toCharges.toFinset = c ∧
      a.toFluxesFive =
        {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
          { M := 0, N := 1 }}⊢ x ∈ liftCharge c
  obtain ⟨x, rfl, h, h2⟩ := h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}⊢ x.reduce ∈ liftCharge c
  rw [liftCharge,𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}⊢ x.reduce ∈
  Multiset.map reduce
    (Multiset.map
      (fun y =>
        Multiset.map (fun z => (z, { M := 1, N := -1 })) y.1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) y.2)
      (Multiset.filter
        (fun x =>
          match x with
          | (s1, s2) => c.val ≤ s1 + s2)
        (toMultisetsThree c ×ˢ toMultisetsThree c)))𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}⊢ ∃
  a ∈
    Multiset.map
      (fun y =>
        Multiset.map (fun z => (z, { M := 1, N := -1 })) y.1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) y.2)
      (Multiset.filter
        (fun x =>
          match x with
          | (s1, s2) => c.val ≤ s1 + s2)
        (toMultisetsThree c ×ˢ toMultisetsThree c)),
  a.reduce = x.reduce Multiset.mem_map𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}⊢ ∃
  a ∈
    Multiset.map
      (fun y =>
        Multiset.map (fun z => (z, { M := 1, N := -1 })) y.1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) y.2)
      (Multiset.filter
        (fun x =>
          match x with
          | (s1, s2) => c.val ≤ s1 + s2)
        (toMultisetsThree c ×ˢ toMultisetsThree c)),
  a.reduce = x.reduce𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}⊢ ∃
  a ∈
    Multiset.map
      (fun y =>
        Multiset.map (fun z => (z, { M := 1, N := -1 })) y.1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) y.2)
      (Multiset.filter
        (fun x =>
          match x with
          | (s1, s2) => c.val ≤ s1 + s2)
        (toMultisetsThree c ×ˢ toMultisetsThree c)),
  a.reduce = x.reduce]𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}⊢ ∃
  a ∈
    Multiset.map
      (fun y =>
        Multiset.map (fun z => (z, { M := 1, N := -1 })) y.1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) y.2)
      (Multiset.filter
        (fun x =>
          match x with
          | (s1, s2) => c.val ≤ s1 + s2)
        (toMultisetsThree c ×ˢ toMultisetsThree c)),
  a.reduce = x.reduce
  use xh𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}⊢ x ∈
    Multiset.map
      (fun y =>
        Multiset.map (fun z => (z, { M := 1, N := -1 })) y.1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) y.2)
      (Multiset.filter
        (fun x =>
          match x with
          | (s1, s2) => c.val ≤ s1 + s2)
        (toMultisetsThree c ×ˢ toMultisetsThree c)) ∧
  x.reduce = x.reduce
  simp only [Int.reduceNeg, Multiset.mem_map, Multiset.mem_filter, Multiset.mem_product,
    mem_toMultisetsThree_iff, Prod.exists, and_true]h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}⊢ ∃ a b,
  (((a.toFinset ⊆ c ∧ a.card = 3) ∧ b.toFinset ⊆ c ∧ b.card = 3) ∧ c.val ≤ a + b) ∧
    Multiset.map (fun z => (z, { M := 1, N := -1 })) a + Multiset.map (fun z => (z, { M := 0, N := 1 })) b = x
  let s1 := (x.filter (fun y => y.2 = ⟨1, -1⟩)).map Prod.fsth𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)⊢ ∃ a b,
  (((a.toFinset ⊆ c ∧ a.card = 3) ∧ b.toFinset ⊆ c ∧ b.card = 3) ∧ c.val ≤ a + b) ∧
    Multiset.map (fun z => (z, { M := 1, N := -1 })) a + Multiset.map (fun z => (z, { M := 0, N := 1 })) b = x
  let s2 := (x.filter (fun y => y.2 = ⟨0, 1⟩)).map Prod.fsth𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)⊢ ∃ a b,
  (((a.toFinset ⊆ c ∧ a.card = 3) ∧ b.toFinset ⊆ c ∧ b.card = 3) ∧ c.val ≤ a + b) ∧
    Multiset.map (fun z => (z, { M := 1, N := -1 })) a + Multiset.map (fun z => (z, { M := 0, N := 1 })) b = x
  use s1, s2h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)⊢ (((s1.toFinset ⊆ c ∧ s1.card = 3) ∧ s2.toFinset ⊆ c ∧ s2.card = 3) ∧ c.val ≤ s1 + s2) ∧
  Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) s2 = x
  have hcard : ∀ v : Fluxes, (x.filter (fun y => y.2 = v)).card =
      (x.toFluxesFive.filter (fun y => y = v)).card := by𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:∃ a,
  a.reduce = x ∧
    a.toCharges.toFinset = c ∧
      a.toFluxesFive =
        {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
          { M := 0, N := 1 }}⊢ x ∈ liftCharge ch𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).card⊢ (((s1.toFinset ⊆ c ∧ s1.card = 3) ∧ s2.toFinset ⊆ c ∧ s2.card = 3) ∧ c.val ≤ s1 + s2) ∧
  Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) s2 = x
    intro v𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)v:Fluxes⊢ (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardh𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).card⊢ (((s1.toFinset ⊆ c ∧ s1.card = 3) ∧ s2.toFinset ⊆ c ∧ s2.card = 3) ∧ c.val ≤ s1 + s2) ∧
  Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) s2 = x
    rw [toFluxesFive,𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)v:Fluxes⊢ (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) (Multiset.map Prod.snd x)).card𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)v:Fluxes⊢ (Multiset.filter (fun y => y.2 = v) x).card =
  (Multiset.map Prod.snd (Multiset.filter ((fun y => y = v) ∘ Prod.snd) x)).cardh𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).card⊢ (((s1.toFinset ⊆ c ∧ s1.card = 3) ∧ s2.toFinset ⊆ c ∧ s2.card = 3) ∧ c.val ≤ s1 + s2) ∧
  Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) s2 = x Multiset.filter_map𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)v:Fluxes⊢ (Multiset.filter (fun y => y.2 = v) x).card =
  (Multiset.map Prod.snd (Multiset.filter ((fun y => y = v) ∘ Prod.snd) x)).card𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)v:Fluxes⊢ (Multiset.filter (fun y => y.2 = v) x).card =
  (Multiset.map Prod.snd (Multiset.filter ((fun y => y = v) ∘ Prod.snd) x)).cardh𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).card⊢ (((s1.toFinset ⊆ c ∧ s1.card = 3) ∧ s2.toFinset ⊆ c ∧ s2.card = 3) ∧ c.val ≤ s1 + s2) ∧
  Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) s2 = x]𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)v:Fluxes⊢ (Multiset.filter (fun y => y.2 = v) x).card =
  (Multiset.map Prod.snd (Multiset.filter ((fun y => y = v) ∘ Prod.snd) x)).cardh𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).card⊢ (((s1.toFinset ⊆ c ∧ s1.card = 3) ∧ s2.toFinset ⊆ c ∧ s2.card = 3) ∧ c.val ≤ s1 + s2) ∧
  Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) s2 = x
    simph𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).card⊢ (((s1.toFinset ⊆ c ∧ s1.card = 3) ∧ s2.toFinset ⊆ c ∧ s2.card = 3) ∧ c.val ≤ s1 + s2) ∧
  Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) s2 = xh𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).card⊢ (((s1.toFinset ⊆ c ∧ s1.card = 3) ∧ s2.toFinset ⊆ c ∧ s2.card = 3) ∧ c.val ≤ s1 + s2) ∧
  Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) s2 = x
  have hmap : ∀ v : Fluxes, Multiset.map (fun y => (y.1, v)) (x.filter (fun y => y.2 = v)) =
      x.filter (fun y => y.2 = v) := by𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:∃ a,
  a.reduce = x ∧
    a.toCharges.toFinset = c ∧
      a.toFluxesFive =
        {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
          { M := 0, N := 1 }}⊢ x ∈ liftCharge ch𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) x⊢ (((s1.toFinset ⊆ c ∧ s1.card = 3) ∧ s2.toFinset ⊆ c ∧ s2.card = 3) ∧ c.val ≤ s1 + s2) ∧
  Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) s2 = x
    intro v𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardv:Fluxes⊢ Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xh𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) x⊢ (((s1.toFinset ⊆ c ∧ s1.card = 3) ∧ s2.toFinset ⊆ c ∧ s2.card = 3) ∧ c.val ≤ s1 + s2) ∧
  Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) s2 = x
    refine (Multiset.map_congr rfl fun y hy => ?_).trans (Multiset.map_id _)𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardv:Fluxesy:𝓩 × Fluxeshy:y ∈ Multiset.filter (fun y => y.2 = v) x⊢ (y.1, v) = id yh𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) x⊢ (((s1.toFinset ⊆ c ∧ s1.card = 3) ∧ s2.toFinset ⊆ c ∧ s2.card = 3) ∧ c.val ≤ s1 + s2) ∧
  Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) s2 = x
    simp [← (Multiset.mem_filter.mp hy).2]h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) x⊢ (((s1.toFinset ⊆ c ∧ s1.card = 3) ∧ s2.toFinset ⊆ c ∧ s2.card = 3) ∧ c.val ≤ s1 + s2) ∧
  Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) s2 = xh𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) x⊢ (((s1.toFinset ⊆ c ∧ s1.card = 3) ∧ s2.toFinset ⊆ c ∧ s2.card = 3) ∧ c.val ≤ s1 + s2) ∧
  Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) s2 = x
  have hx : Multiset.filter (fun y => y.2 = ⟨0, 1⟩) x
        = Multiset.filter (fun y => ¬ y.2 = ⟨1, -1⟩) x := by𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:∃ a,
  a.reduce = x ∧
    a.toCharges.toFinset = c ∧
      a.toFluxesFive =
        {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
          { M := 0, N := 1 }}⊢ x ∈ liftCharge ch𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ (((s1.toFinset ⊆ c ∧ s1.card = 3) ∧ s2.toFinset ⊆ c ∧ s2.card = 3) ∧ c.val ≤ s1 + s2) ∧
  Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) s2 = x
    refine Multiset.filter_congr ?_𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) x⊢ ∀ x_1 ∈ x, x_1.2 = { M := 0, N := 1 } ↔ ¬x_1.2 = { M := 1, N := -1 }h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ (((s1.toFinset ⊆ c ∧ s1.card = 3) ∧ s2.toFinset ⊆ c ∧ s2.card = 3) ∧ c.val ≤ s1 + s2) ∧
  Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) s2 = x
    intro p hp𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xp:𝓩 × Fluxeshp:p ∈ x⊢ p.2 = { M := 0, N := 1 } ↔ ¬p.2 = { M := 1, N := -1 }h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ (((s1.toFinset ⊆ c ∧ s1.card = 3) ∧ s2.toFinset ⊆ c ∧ s2.card = 3) ∧ c.val ≤ s1 + s2) ∧
  Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) s2 = x
    have h1 : p.2 ∈ x.toFluxesFive := by𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:∃ a,
  a.reduce = x ∧
    a.toCharges.toFinset = c ∧
      a.toFluxesFive =
        {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
          { M := 0, N := 1 }}⊢ x ∈ liftCharge c𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xp:𝓩 × Fluxeshp:p ∈ xh1:p.2 ∈ x.toFluxesFive⊢ p.2 = { M := 0, N := 1 } ↔ ¬p.2 = { M := 1, N := -1 }h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ (((s1.toFinset ⊆ c ∧ s1.card = 3) ∧ s2.toFinset ⊆ c ∧ s2.card = 3) ∧ c.val ≤ s1 + s2) ∧
  Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) s2 = x simp [toFluxesFive]𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xp:𝓩 × Fluxeshp:p ∈ x⊢ ∃ a, (a, p.2) ∈ x𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xp:𝓩 × Fluxeshp:p ∈ xh1:p.2 ∈ x.toFluxesFive⊢ p.2 = { M := 0, N := 1 } ↔ ¬p.2 = { M := 1, N := -1 }h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ (((s1.toFinset ⊆ c ∧ s1.card = 3) ∧ s2.toFinset ⊆ c ∧ s2.card = 3) ∧ c.val ≤ s1 + s2) ∧
  Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) s2 = x; use p.1𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xp:𝓩 × Fluxeshp:p ∈ xh1:p.2 ∈ x.toFluxesFive⊢ p.2 = { M := 0, N := 1 } ↔ ¬p.2 = { M := 1, N := -1 }h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ (((s1.toFinset ⊆ c ∧ s1.card = 3) ∧ s2.toFinset ⊆ c ∧ s2.card = 3) ∧ c.val ≤ s1 + s2) ∧
  Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) s2 = x𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xp:𝓩 × Fluxeshp:p ∈ xh1:p.2 ∈ x.toFluxesFive⊢ p.2 = { M := 0, N := 1 } ↔ ¬p.2 = { M := 1, N := -1 }h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ (((s1.toFinset ⊆ c ∧ s1.card = 3) ∧ s2.toFinset ⊆ c ∧ s2.card = 3) ∧ c.val ≤ s1 + s2) ∧
  Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) s2 = x
    rw [h2𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xp:𝓩 × Fluxeshp:p ∈ xh1:p.2 ∈
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}⊢ p.2 = { M := 0, N := 1 } ↔ ¬p.2 = { M := 1, N := -1 }𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xp:𝓩 × Fluxeshp:p ∈ xh1:p.2 ∈
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}⊢ p.2 = { M := 0, N := 1 } ↔ ¬p.2 = { M := 1, N := -1 }h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ (((s1.toFinset ⊆ c ∧ s1.card = 3) ∧ s2.toFinset ⊆ c ∧ s2.card = 3) ∧ c.val ≤ s1 + s2) ∧
  Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) s2 = x] at h1𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xp:𝓩 × Fluxeshp:p ∈ xh1:p.2 ∈
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}⊢ p.2 = { M := 0, N := 1 } ↔ ¬p.2 = { M := 1, N := -1 }h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ (((s1.toFinset ⊆ c ∧ s1.card = 3) ∧ s2.toFinset ⊆ c ∧ s2.card = 3) ∧ c.val ≤ s1 + s2) ∧
  Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) s2 = x
    simp_all𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = cs1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)p:𝓩 × Fluxesh2:x.toFluxesFive =
  { M := 1, N := -1 } ::ₘ
    { M := 1, N := -1 } ::ₘ { M := 1, N := -1 } ::ₘ { M := 0, N := 1 } ::ₘ { M := 0, N := 1 } ::ₘ {{ M := 0, N := 1 }}hcard:∀ (v : Fluxes),
  (Multiset.filter (fun y => y.2 = v) x).card =
    (Multiset.filter (fun y => y = v)
        ({ M := 1, N := -1 } ::ₘ
          { M := 1, N := -1 } ::ₘ
            { M := 1, N := -1 } ::ₘ { M := 0, N := 1 } ::ₘ { M := 0, N := 1 } ::ₘ {{ M := 0, N := 1 }})).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhp:p ∈ xh1:p.2 = { M := 1, N := -1 } ∨ p.2 = { M := 0, N := 1 }⊢ p.2 = { M := 0, N := 1 } ↔ ¬p.2 = { M := 1, N := -1 }h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ (((s1.toFinset ⊆ c ∧ s1.card = 3) ∧ s2.toFinset ⊆ c ∧ s2.card = 3) ∧ c.val ≤ s1 + s2) ∧
  Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) s2 = x
    rcases h1 with hp | hpinl𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = cs1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)p:𝓩 × Fluxesh2:x.toFluxesFive =
  { M := 1, N := -1 } ::ₘ
    { M := 1, N := -1 } ::ₘ { M := 1, N := -1 } ::ₘ { M := 0, N := 1 } ::ₘ { M := 0, N := 1 } ::ₘ {{ M := 0, N := 1 }}hcard:∀ (v : Fluxes),
  (Multiset.filter (fun y => y.2 = v) x).card =
    (Multiset.filter (fun y => y = v)
        ({ M := 1, N := -1 } ::ₘ
          { M := 1, N := -1 } ::ₘ
            { M := 1, N := -1 } ::ₘ { M := 0, N := 1 } ::ₘ { M := 0, N := 1 } ::ₘ {{ M := 0, N := 1 }})).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhp✝:p ∈ xhp:p.2 = { M := 1, N := -1 }⊢ p.2 = { M := 0, N := 1 } ↔ ¬p.2 = { M := 1, N := -1 }inr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = cs1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)p:𝓩 × Fluxesh2:x.toFluxesFive =
  { M := 1, N := -1 } ::ₘ
    { M := 1, N := -1 } ::ₘ { M := 1, N := -1 } ::ₘ { M := 0, N := 1 } ::ₘ { M := 0, N := 1 } ::ₘ {{ M := 0, N := 1 }}hcard:∀ (v : Fluxes),
  (Multiset.filter (fun y => y.2 = v) x).card =
    (Multiset.filter (fun y => y = v)
        ({ M := 1, N := -1 } ::ₘ
          { M := 1, N := -1 } ::ₘ
            { M := 1, N := -1 } ::ₘ { M := 0, N := 1 } ::ₘ { M := 0, N := 1 } ::ₘ {{ M := 0, N := 1 }})).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhp✝:p ∈ xhp:p.2 = { M := 0, N := 1 }⊢ p.2 = { M := 0, N := 1 } ↔ ¬p.2 = { M := 1, N := -1 }h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ (((s1.toFinset ⊆ c ∧ s1.card = 3) ∧ s2.toFinset ⊆ c ∧ s2.card = 3) ∧ c.val ≤ s1 + s2) ∧
  Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) s2 = x <;>inl𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = cs1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)p:𝓩 × Fluxesh2:x.toFluxesFive =
  { M := 1, N := -1 } ::ₘ
    { M := 1, N := -1 } ::ₘ { M := 1, N := -1 } ::ₘ { M := 0, N := 1 } ::ₘ { M := 0, N := 1 } ::ₘ {{ M := 0, N := 1 }}hcard:∀ (v : Fluxes),
  (Multiset.filter (fun y => y.2 = v) x).card =
    (Multiset.filter (fun y => y = v)
        ({ M := 1, N := -1 } ::ₘ
          { M := 1, N := -1 } ::ₘ
            { M := 1, N := -1 } ::ₘ { M := 0, N := 1 } ::ₘ { M := 0, N := 1 } ::ₘ {{ M := 0, N := 1 }})).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhp✝:p ∈ xhp:p.2 = { M := 1, N := -1 }⊢ p.2 = { M := 0, N := 1 } ↔ ¬p.2 = { M := 1, N := -1 }inr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = cs1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)p:𝓩 × Fluxesh2:x.toFluxesFive =
  { M := 1, N := -1 } ::ₘ
    { M := 1, N := -1 } ::ₘ { M := 1, N := -1 } ::ₘ { M := 0, N := 1 } ::ₘ { M := 0, N := 1 } ::ₘ {{ M := 0, N := 1 }}hcard:∀ (v : Fluxes),
  (Multiset.filter (fun y => y.2 = v) x).card =
    (Multiset.filter (fun y => y = v)
        ({ M := 1, N := -1 } ::ₘ
          { M := 1, N := -1 } ::ₘ
            { M := 1, N := -1 } ::ₘ { M := 0, N := 1 } ::ₘ { M := 0, N := 1 } ::ₘ {{ M := 0, N := 1 }})).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhp✝:p ∈ xhp:p.2 = { M := 0, N := 1 }⊢ p.2 = { M := 0, N := 1 } ↔ ¬p.2 = { M := 1, N := -1 }h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ (((s1.toFinset ⊆ c ∧ s1.card = 3) ∧ s2.toFinset ⊆ c ∧ s2.card = 3) ∧ c.val ≤ s1 + s2) ∧
  Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) s2 = x simp [hp]h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ (((s1.toFinset ⊆ c ∧ s1.card = 3) ∧ s2.toFinset ⊆ c ∧ s2.card = 3) ∧ c.val ≤ s1 + s2) ∧
  Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) s2 = xh𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ (((s1.toFinset ⊆ c ∧ s1.card = 3) ∧ s2.toFinset ⊆ c ∧ s2.card = 3) ∧ c.val ≤ s1 + s2) ∧
  Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) s2 = x
  refine ⟨⟨⟨⟨?_, ?_⟩, ⟨?_, ?_⟩⟩, ?_⟩, ?_⟩h.refine_1𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ s1.toFinset ⊆ ch.refine_2𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ s1.card = 3h.refine_3𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ s2.toFinset ⊆ ch.refine_4𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ s2.card = 3h.refine_5𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ c.val ≤ s1 + s2h.refine_6𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) s2 = x
  ·h.refine_1𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ s1.toFinset ⊆ c simp [s1, ← h, toCharges]All goals completed! 🐙
  ·h.refine_2𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ s1.card = 3 simp [s1]h.refine_2𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x).card = 3
    rw [hcard ⟨1, -1⟩,h.refine_2𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ (Multiset.filter (fun y => y = { M := 1, N := -1 }) x.toFluxesFive).card = 3h.refine_2𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ (Multiset.filter (fun y => y = { M := 1, N := -1 })
      {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
        { M := 0, N := 1 }}).card =
  3 h2h.refine_2𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ (Multiset.filter (fun y => y = { M := 1, N := -1 })
      {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
        { M := 0, N := 1 }}).card =
  3h.refine_2𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ (Multiset.filter (fun y => y = { M := 1, N := -1 })
      {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
        { M := 0, N := 1 }}).card =
  3]h.refine_2𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ (Multiset.filter (fun y => y = { M := 1, N := -1 })
      {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
        { M := 0, N := 1 }}).card =
  3
    decideAll goals completed! 🐙
  ·h.refine_3𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ s2.toFinset ⊆ c simp [s2, ← h, toCharges]All goals completed! 🐙
  ·h.refine_4𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ s2.card = 3 simp [s2]h.refine_4𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x).card = 3
    rw [hcard ⟨0, 1⟩,h.refine_4𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ (Multiset.filter (fun y => y = { M := 0, N := 1 }) x.toFluxesFive).card = 3h.refine_4𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ (Multiset.filter (fun y => y = { M := 0, N := 1 })
      {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
        { M := 0, N := 1 }}).card =
  3 h2h.refine_4𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ (Multiset.filter (fun y => y = { M := 0, N := 1 })
      {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
        { M := 0, N := 1 }}).card =
  3h.refine_4𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ (Multiset.filter (fun y => y = { M := 0, N := 1 })
      {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
        { M := 0, N := 1 }}).card =
  3]h.refine_4𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ (Multiset.filter (fun y => y = { M := 0, N := 1 })
      {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
        { M := 0, N := 1 }}).card =
  3
    decideAll goals completed! 🐙
  ·h.refine_5𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ c.val ≤ s1 + s2 rw [← hh.refine_5𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ x.toCharges.toFinset.val ≤ s1 + s2h.refine_5𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ x.toCharges.toFinset.val ≤ s1 + s2]h.refine_5𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ x.toCharges.toFinset.val ≤ s1 + s2
    simp [s1, s2, toCharges]h.refine_5𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ (Multiset.map Prod.fst x).dedup ≤
  Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x) +
    Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)
    rw [← Multiset.map_addh.refine_5𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ (Multiset.map Prod.fst x).dedup ≤
  Multiset.map Prod.fst
    (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x + Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)h.refine_5𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ (Multiset.map Prod.fst x).dedup ≤
  Multiset.map Prod.fst
    (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x + Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)]h.refine_5𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ (Multiset.map Prod.fst x).dedup ≤
  Multiset.map Prod.fst
    (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x + Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)
    refine (Multiset.le_iff_subset (Multiset.nodup_dedup (Multiset.map Prod.fst x))).mpr ?_h.refine_5𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ (Multiset.map Prod.fst x).dedup ⊆
  Multiset.map Prod.fst
    (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x + Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)
    simp only [Multiset.dedup_subset']h.refine_5𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ Multiset.map Prod.fst x ⊆
  Multiset.map Prod.fst
    (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x + Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)
    refine Multiset.map_subset_map ?_h.refine_5𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ x ⊆ Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x + Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x
    rw [hx,h.refine_5𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ x ⊆ Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x + Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) xh.refine_5𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ x ⊆ x Multiset.filter_add_noth.refine_5𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ x ⊆ xh.refine_5𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ x ⊆ x]h.refine_5𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ x ⊆ x
    exact fun ⦃a⦄ a => aAll goals completed! 🐙
  ·h.refine_6𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ Multiset.map (fun z => (z, { M := 1, N := -1 })) s1 + Multiset.map (fun z => (z, { M := 0, N := 1 })) s2 = x simp [s1, s2]h.refine_6𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ Multiset.map (fun x => (x.1, { M := 1, N := -1 })) (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x) +
    Multiset.map (fun x => (x.1, { M := 0, N := 1 })) (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x) =
  x
    rw [hmap ⟨1, -1⟩,h.refine_6𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x +
    Multiset.map (fun x => (x.1, { M := 0, N := 1 })) (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x) =
  xh.refine_6𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x + Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x = x hmap ⟨0, 1⟩,h.refine_6𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x + Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = xh.refine_6𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x + Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x = x hxh.refine_6𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x + Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x = xh.refine_6𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x + Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x = x]h.refine_6𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}s1:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x)s2:Multiset 𝓩 := Multiset.map Prod.fst (Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x)hcard:∀ (v : Fluxes), (Multiset.filter (fun y => y.2 = v) x).card = (Multiset.filter (fun y => y = v) x.toFluxesFive).cardhmap:∀ (v : Fluxes),
  Multiset.map (fun y => (y.1, v)) (Multiset.filter (fun y => y.2 = v) x) = Multiset.filter (fun y => y.2 = v) xhx:Multiset.filter (fun y => y.2 = { M := 0, N := 1 }) x = Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x⊢ Multiset.filter (fun y => y.2 = { M := 1, N := -1 }) x + Multiset.filter (fun y => ¬y.2 = { M := 1, N := -1 }) x = x
    exact Multiset.filter_add_not (fun y => y.2 = ⟨1, -1⟩) xAll goals completed! 🐙lemma mem_liftCharge_iff_exists (c : Finset 𝓩) {x : FiveQuanta 𝓩} :
    x ∈ liftCharge c ↔ ∃ a : FiveQuanta 𝓩, a.reduce = x ∧
      a.toCharges.toFinset = c ∧ a.toFluxesFive =
      {⟨1, -1⟩, ⟨1, -1⟩, ⟨1, -1⟩, ⟨0, 1⟩, ⟨0, 1⟩, ⟨0, 1⟩} :=
  ⟨exists_toCharges_toFluxesFive_of_mem_liftCharge c,
    mem_liftCharge_of_exists_toCharges_toFluxesFive c⟩

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



lemma hasNoZero_of_mem_liftCharge (c : Finset 𝓩) {x : FiveQuanta 𝓩}
    (h : x ∈ liftCharge c) : x.toFluxesFive.HasNoZero := by𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x ∈ liftCharge c⊢ x.toFluxesFive.HasNoZero
  rw [mem_liftCharge_iff_exists𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:∃ a,
  a.reduce = x ∧
    a.toCharges.toFinset = c ∧
      a.toFluxesFive =
        {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
          { M := 0, N := 1 }}⊢ x.toFluxesFive.HasNoZero𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:∃ a,
  a.reduce = x ∧
    a.toCharges.toFinset = c ∧
      a.toFluxesFive =
        {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
          { M := 0, N := 1 }}⊢ x.toFluxesFive.HasNoZero] at h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:∃ a,
  a.reduce = x ∧
    a.toCharges.toFinset = c ∧
      a.toFluxesFive =
        {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
          { M := 0, N := 1 }}⊢ x.toFluxesFive.HasNoZero
  obtain ⟨x, rfl, h1, h2⟩ := h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}⊢ x.reduce.toFluxesFive.HasNoZero
  intro hf𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}hf:0 ∈ x.reduce.toFluxesFive⊢ False
  have hx := mem_powerset_sum_of_mem_reduce_toFluxesFive_filter hf𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}hf:0 ∈ x.reduce.toFluxesFivehx:0 ∈ Multiset.map (fun s => s.sum) (Multiset.filter (fun s => s ≠ ∅) (Multiset.powerset x.toFluxesFive))⊢ False
  rw [h2𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}hf:0 ∈ x.reduce.toFluxesFivehx:0 ∈
  Multiset.map (fun s => s.sum)
    (Multiset.filter (fun s => s ≠ ∅)
      (Multiset.powerset
        {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
          { M := 0, N := 1 }}))⊢ False𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}hf:0 ∈ x.reduce.toFluxesFivehx:0 ∈
  Multiset.map (fun s => s.sum)
    (Multiset.filter (fun s => s ≠ ∅)
      (Multiset.powerset
        {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
          { M := 0, N := 1 }}))⊢ False] at hx𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}hf:0 ∈ x.reduce.toFluxesFivehx:0 ∈
  Multiset.map (fun s => s.sum)
    (Multiset.filter (fun s => s ≠ ∅)
      (Multiset.powerset
        {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
          { M := 0, N := 1 }}))⊢ False
  revert hx𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}hf:0 ∈ x.reduce.toFluxesFive⊢ 0 ∈
    Multiset.map (fun s => s.sum)
      (Multiset.filter (fun s => s ≠ ∅)
        (Multiset.powerset
          {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
            { M := 0, N := 1 }})) →
  False
  decideAll goals completed! 🐙

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



lemma noExotics_of_mem_liftCharge (c : Finset 𝓩) (F : FiveQuanta 𝓩)
    (h : F ∈ liftCharge c) :
    F.toFluxesFive.NoExotics := by𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩F:FiveQuanta 𝓩h:F ∈ liftCharge c⊢ F.toFluxesFive.NoExotics
  rw [mem_liftCharge_iff_exists𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩F:FiveQuanta 𝓩h:∃ a,
  a.reduce = F ∧
    a.toCharges.toFinset = c ∧
      a.toFluxesFive =
        {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
          { M := 0, N := 1 }}⊢ F.toFluxesFive.NoExotics𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩F:FiveQuanta 𝓩h:∃ a,
  a.reduce = F ∧
    a.toCharges.toFinset = c ∧
      a.toFluxesFive =
        {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
          { M := 0, N := 1 }}⊢ F.toFluxesFive.NoExotics] at h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩F:FiveQuanta 𝓩h:∃ a,
  a.reduce = F ∧
    a.toCharges.toFinset = c ∧
      a.toFluxesFive =
        {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
          { M := 0, N := 1 }}⊢ F.toFluxesFive.NoExotics
  obtain ⟨x, rfl, h1, h2⟩ := h𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}⊢ x.reduce.toFluxesFive.NoExotics
  apply reduce_noExotics_of_mem_elemsNoExotics𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}⊢ x.toFluxesFive ∈ FluxesFive.elemsNoExotics
  rw [h2𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}⊢ {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }} ∈
  FluxesFive.elemsNoExotics𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}⊢ {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }} ∈
  FluxesFive.elemsNoExotics]𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toCharges.toFinset = ch2:x.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}⊢ {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }} ∈
  FluxesFive.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 : FiveQuanta 𝓩}
    (h1 : x.toFluxesFive.NoExotics) (h2 : x.toFluxesFive.HasNoZero)
    (h3 : x.toCharges.toFinset = c) (h4 : x.toCharges.Nodup) :
    x ∈ liftCharge c := by𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toFluxesFive.NoExoticsh2:x.toFluxesFive.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Nodup⊢ x ∈ liftCharge c
  have hf : x.toFluxesFive ∈ FluxesFive.elemsNoExotics :=
    (FluxesFive.noExotics_iff_mem_elemsNoExotics _).mp ⟨h1, h2⟩𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toFluxesFive.NoExoticsh2:x.toFluxesFive.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ x ∈ liftCharge c
  rw [mem_liftCharge_iff_exists𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toFluxesFive.NoExoticsh2:x.toFluxesFive.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ ∃ a,
  a.reduce = x ∧
    a.toCharges.toFinset = c ∧
      a.toFluxesFive =
        {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
          { M := 0, N := 1 }}𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toFluxesFive.NoExoticsh2:x.toFluxesFive.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ ∃ a,
  a.reduce = x ∧
    a.toCharges.toFinset = c ∧
      a.toFluxesFive =
        {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
          { M := 0, N := 1 }}]𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toFluxesFive.NoExoticsh2:x.toFluxesFive.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ ∃ a,
  a.reduce = x ∧
    a.toCharges.toFinset = c ∧
      a.toFluxesFive =
        {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
          { M := 0, N := 1 }}
  use x.decomposeh𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toFluxesFive.NoExoticsh2:x.toFluxesFive.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ x.decompose.reduce = x ∧
  x.decompose.toCharges.toFinset = c ∧
    x.decompose.toFluxesFive =
      {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
        { M := 0, N := 1 }}
  apply And.introh.left𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toFluxesFive.NoExoticsh2:x.toFluxesFive.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ x.decompose.reduce = xh.right𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toFluxesFive.NoExoticsh2:x.toFluxesFive.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ x.decompose.toCharges.toFinset = c ∧
  x.decompose.toFluxesFive =
    {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
      { M := 0, N := 1 }}
  ·h.left𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toFluxesFive.NoExoticsh2:x.toFluxesFive.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ x.decompose.reduce = x rw [decompose_reduce x hfh.left𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toFluxesFive.NoExoticsh2:x.toFluxesFive.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ x.reduce = xh.left𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toFluxesFive.NoExoticsh2:x.toFluxesFive.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ x.reduce = x]h.left𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toFluxesFive.NoExoticsh2:x.toFluxesFive.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ x.reduce = x
    exact reduce_eq_self_of_ofCharges_nodup x h4All goals completed! 🐙
  ·h.right𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toFluxesFive.NoExoticsh2:x.toFluxesFive.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ x.decompose.toCharges.toFinset = c ∧
  x.decompose.toFluxesFive =
    {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
      { M := 0, N := 1 }} constructorh.right.left𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toFluxesFive.NoExoticsh2:x.toFluxesFive.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ x.decompose.toCharges.toFinset = ch.right.right𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toFluxesFive.NoExoticsh2:x.toFluxesFive.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ x.decompose.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}
    ·h.right.left𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toFluxesFive.NoExoticsh2:x.toFluxesFive.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ x.decompose.toCharges.toFinset = c trans x.decompose.toCharges.dedup.toFinset𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toFluxesFive.NoExoticsh2:x.toFluxesFive.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ x.decompose.toCharges.toFinset = x.decompose.toCharges.dedup.toFinset𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toFluxesFive.NoExoticsh2:x.toFluxesFive.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ x.decompose.toCharges.dedup.toFinset = c
      ·𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toFluxesFive.NoExoticsh2:x.toFluxesFive.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ x.decompose.toCharges.toFinset = x.decompose.toCharges.dedup.toFinset simpAll goals completed! 🐙
      ·𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toFluxesFive.NoExoticsh2:x.toFluxesFive.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ x.decompose.toCharges.dedup.toFinset = c rw [decompose_toCharges_dedup x hf,𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toFluxesFive.NoExoticsh2:x.toFluxesFive.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ x.toCharges.dedup.toFinset = c𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toFluxesFive.NoExoticsh2:x.toFluxesFive.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ x.toCharges.dedup.toFinset = x.toCharges.toFinset ← h3𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toFluxesFive.NoExoticsh2:x.toFluxesFive.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ x.toCharges.dedup.toFinset = x.toCharges.toFinset𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toFluxesFive.NoExoticsh2:x.toFluxesFive.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ x.toCharges.dedup.toFinset = x.toCharges.toFinset]𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toFluxesFive.NoExoticsh2:x.toFluxesFive.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ x.toCharges.dedup.toFinset = x.toCharges.toFinset
        simpAll goals completed! 🐙
    ·h.right.right𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toFluxesFive.NoExoticsh2:x.toFluxesFive.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ x.decompose.toFluxesFive =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }} rw [decompose_toFluxesFive x hfh.right.right𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toFluxesFive.NoExoticsh2:x.toFluxesFive.HasNoZeroh3:x.toCharges.toFinset = ch4:x.toCharges.Noduphf:x.toFluxesFive ∈ FluxesFive.elemsNoExotics⊢ {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }} =
  {{ M := 1, N := -1 }, { M := 1, N := -1 }, { M := 1, N := -1 }, { M := 0, N := 1 }, { M := 0, N := 1 },
    { M := 0, N := 1 }}All goals completed! 🐙]All goals completed! 🐙



lemma mem_liftCharge_iff (c : Finset 𝓩) (x : FiveQuanta 𝓩) :
    x ∈ liftCharge c ↔ x.toFluxesFive ∈ FluxesFive.elemsNoExotics
      ∧ x.toCharges.toFinset = c ∧ x.toCharges.Nodup := by𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩⊢ x ∈ liftCharge c ↔ x.toFluxesFive ∈ FluxesFive.elemsNoExotics ∧ x.toCharges.toFinset = c ∧ x.toCharges.Nodup
  constructormp𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩⊢ x ∈ liftCharge c → x.toFluxesFive ∈ FluxesFive.elemsNoExotics ∧ x.toCharges.toFinset = c ∧ x.toCharges.Nodupmpr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩⊢ x.toFluxesFive ∈ FluxesFive.elemsNoExotics ∧ x.toCharges.toFinset = c ∧ x.toCharges.Nodup → x ∈ liftCharge c
  ·mp𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩⊢ x ∈ liftCharge c → x.toFluxesFive ∈ FluxesFive.elemsNoExotics ∧ x.toCharges.toFinset = c ∧ x.toCharges.Nodup intro hmp𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x ∈ liftCharge c⊢ x.toFluxesFive ∈ FluxesFive.elemsNoExotics ∧ x.toCharges.toFinset = c ∧ x.toCharges.Nodup
    refine ⟨?_, ?_, ?_⟩mp.refine_1𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x ∈ liftCharge c⊢ x.toFluxesFive ∈ FluxesFive.elemsNoExoticsmp.refine_2𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x ∈ liftCharge c⊢ x.toCharges.toFinset = cmp.refine_3𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x ∈ liftCharge c⊢ x.toCharges.Nodup
    ·mp.refine_1𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x ∈ liftCharge c⊢ x.toFluxesFive ∈ FluxesFive.elemsNoExotics rw [← FluxesFive.noExotics_iff_mem_elemsNoExoticsmp.refine_1𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x ∈ liftCharge c⊢ x.toFluxesFive.NoExotics ∧ x.toFluxesFive.HasNoZeromp.refine_1𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x ∈ liftCharge c⊢ x.toFluxesFive.NoExotics ∧ x.toFluxesFive.HasNoZero]mp.refine_1𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x ∈ liftCharge c⊢ x.toFluxesFive.NoExotics ∧ x.toFluxesFive.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:FiveQuanta 𝓩h:x ∈ liftCharge c⊢ x.toCharges.toFinset = c exact toCharges_toFinset_of_mem_liftCharge c hAll goals completed! 🐙
    ·mp.refine_3𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h:x ∈ liftCharge c⊢ x.toCharges.Nodup exact toCharges_nodup_of_mem_liftCharge c hAll goals completed! 🐙
  ·mpr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩⊢ x.toFluxesFive ∈ FluxesFive.elemsNoExotics ∧ x.toCharges.toFinset = c ∧ x.toCharges.Nodup → x ∈ liftCharge c intro ⟨h1, h2, h3⟩mpr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toFluxesFive ∈ FluxesFive.elemsNoExoticsh2:x.toCharges.toFinset = ch3:x.toCharges.Nodup⊢ x ∈ liftCharge c
    rw [← FluxesFive.noExotics_iff_mem_elemsNoExoticsmpr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toFluxesFive.NoExotics ∧ x.toFluxesFive.HasNoZeroh2:x.toCharges.toFinset = ch3:x.toCharges.Nodup⊢ x ∈ liftCharge cmpr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toFluxesFive.NoExotics ∧ x.toFluxesFive.HasNoZeroh2:x.toCharges.toFinset = ch3:x.toCharges.Nodup⊢ x ∈ liftCharge c] at h1mpr𝓩:Typeinst✝:DecidableEq 𝓩c:Finset 𝓩x:FiveQuanta 𝓩h1:x.toFluxesFive.NoExotics ∧ x.toFluxesFive.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 : FiveQuanta 𝓩) (h : F ∈ liftCharge c) :
    FiveQuanta.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:FiveQuanta 𝓩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:FiveQuanta 𝓩h:F.toFluxesFive ∈ FluxesFive.elemsNoExotics ∧ F.toCharges.toFinset = c ∧ F.toCharges.Nodup⊢ (reduce (Multiset.map (fun y => (f y.1, y.2)) F)).toFluxesFive ∈ FluxesFive.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:FiveQuanta 𝓩h:F.toFluxesFive ∈ FluxesFive.elemsNoExotics ∧ F.toCharges.toFinset = c ∧ F.toCharges.Nodup⊢ (reduce (Multiset.map (fun y => (f y.1, y.2)) F)).toFluxesFive ∈ FluxesFive.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:FiveQuanta 𝓩h:F.toFluxesFive ∈ FluxesFive.elemsNoExotics ∧ F.toCharges.toFinset = c ∧ F.toCharges.Nodup⊢ (reduce (Multiset.map (fun y => (f y.1, y.2)) F)).toFluxesFive ∈ FluxesFive.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:FiveQuanta 𝓩h:F.toFluxesFive ∈ FluxesFive.elemsNoExotics ∧ F.toCharges.toFinset = c ∧ F.toCharges.Nodup⊢ (reduce (Multiset.map (fun y => (f y.1, y.2)) F)).toFluxesFive ∈ FluxesFive.elemsNoExoticsrefine_2𝓩:Type𝓩1:Typeinst✝³:DecidableEq 𝓩inst✝²:DecidableEq 𝓩1inst✝¹:CommRing 𝓩inst✝:CommRing 𝓩1f:𝓩 →+* 𝓩1c:Finset 𝓩F:FiveQuanta 𝓩h:F.toFluxesFive ∈ FluxesFive.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:FiveQuanta 𝓩h:F.toFluxesFive ∈ FluxesFive.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:FiveQuanta 𝓩h:F.toFluxesFive ∈ FluxesFive.elemsNoExotics ∧ F.toCharges.toFinset = c ∧ F.toCharges.Nodup⊢ (reduce (Multiset.map (fun y => (f y.1, y.2)) F)).toFluxesFive ∈ FluxesFive.elemsNoExotics apply reduce_mem_elemsNoExoticsrefine_1𝓩:Type𝓩1:Typeinst✝³:DecidableEq 𝓩inst✝²:DecidableEq 𝓩1inst✝¹:CommRing 𝓩inst✝:CommRing 𝓩1f:𝓩 →+* 𝓩1c:Finset 𝓩F:FiveQuanta 𝓩h:F.toFluxesFive ∈ FluxesFive.elemsNoExotics ∧ F.toCharges.toFinset = c ∧ F.toCharges.Nodup⊢ toFluxesFive (Multiset.map (fun y => (f y.1, y.2)) F) ∈ FluxesFive.elemsNoExotics
    simpa [toFluxesFive, Multiset.map_map] using h.1All goals completed! 🐙
  ·refine_2𝓩:Type𝓩1:Typeinst✝³:DecidableEq 𝓩inst✝²:DecidableEq 𝓩1inst✝¹:CommRing 𝓩inst✝:CommRing 𝓩1f:𝓩 →+* 𝓩1c:Finset 𝓩F:FiveQuanta 𝓩h:F.toFluxesFive ∈ FluxesFive.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:FiveQuanta 𝓩h:F.toFluxesFive ∈ FluxesFive.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:FiveQuanta 𝓩h:F.toFluxesFive ∈ FluxesFive.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:FiveQuanta 𝓩h:F.toFluxesFive ∈ FluxesFive.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:FiveQuanta 𝓩h:F.toFluxesFive ∈ FluxesFive.elemsNoExotics ∧ F.toCharges.toFinset = c ∧ F.toCharges.Nodup⊢ (reduce (Multiset.map (fun y => (f y.1, y.2)) F)).toCharges.Nodup simp [reduce_toCharges]All goals completed! 🐙

E. Anomaly cancellation coefficients

E.1. Anomaly coefficients of a `FiveQuanta`

The anomaly coefficient of a FiveQuanta is given by the pair of integers: (∑ᵢ qᵢ Nᵢ, ∑ᵢ 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 : FiveQuanta 𝓩) : 𝓩 × 𝓩 :=
  ((F.map fun x => x.2.2 • x.1).sum, (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 : FiveQuanta 𝓩) :
    FiveQuanta.anomalyCoefficient (F.map fun y => (f y.1, y.2) : FiveQuanta 𝓩1) =
    (f.prodMap f) F.anomalyCoefficient := by𝓩:Type𝓩1:Typeinst✝¹:CommRing 𝓩inst✝:CommRing 𝓩1f:𝓩 →+* 𝓩1F:FiveQuanta 𝓩⊢ anomalyCoefficient (Multiset.map (fun y => (f y.1, y.2)) F) = (f.prodMap f) F.anomalyCoefficient
  simp [FiveQuanta.anomalyCoefficient, map_multiset_sum, Multiset.map_map]All goals completed! 🐙

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



lemma anomalyCoefficient_of_reduce (F : FiveQuanta 𝓩) [DecidableEq 𝓩] :
    F.reduce.anomalyCoefficient = F.anomalyCoefficient := by𝓩:Typeinst✝¹:CommRing 𝓩F:FiveQuanta 𝓩inst✝:DecidableEq 𝓩⊢ F.reduce.anomalyCoefficient = F.anomalyCoefficient
  have reduce_sum_N_mul_eq : ∀ h : 𝓩 → 𝓩, (F.reduce.map fun x => (x.2.N : 𝓩) * h x.1).sum =
      (F.map fun x => (x.2.N : 𝓩) * h x.1).sum := by
    intro h𝓩:Typeinst✝¹:CommRing 𝓩F:FiveQuanta 𝓩inst✝:DecidableEq 𝓩h:𝓩 → 𝓩⊢ (Multiset.map (fun x => ↑x.2.N * h x.1) F.reduce).sum = (Multiset.map (fun x => ↑x.2.N * h x.1) F).sum𝓩:Typeinst✝¹:CommRing 𝓩F:FiveQuanta 𝓩inst✝:DecidableEq 𝓩reduce_sum_N_mul_eq:∀ (h : 𝓩 → 𝓩), (Multiset.map (fun x => ↑x.2.N * h x.1) F.reduce).sum = (Multiset.map (fun x => ↑x.2.N * h x.1) F).sum⊢ F.reduce.anomalyCoefficient = F.anomalyCoefficient
    let f : 𝓩 → Fluxes →+ 𝓩 := fun q5 =>
      { toFun := fun x => x.N • h q5
        map_zero' := by𝓩:Typeinst✝¹:CommRing 𝓩F:FiveQuanta 𝓩inst✝:DecidableEq 𝓩h:𝓩 → 𝓩q5:𝓩⊢ Fluxes.N 0 • h q5 = 0𝓩:Typeinst✝¹:CommRing 𝓩F:FiveQuanta 𝓩inst✝:DecidableEq 𝓩h:𝓩 → 𝓩f:𝓩 → Fluxes →+ 𝓩 := fun q5 => { toFun := fun x => x.N • h q5, map_zero' := ⋯, map_add' := ⋯ }⊢ (Multiset.map (fun x => ↑x.2.N * h x.1) F.reduce).sum = (Multiset.map (fun x => ↑x.2.N * h x.1) F).sum𝓩:Typeinst✝¹:CommRing 𝓩F:FiveQuanta 𝓩inst✝:DecidableEq 𝓩reduce_sum_N_mul_eq:∀ (h : 𝓩 → 𝓩), (Multiset.map (fun x => ↑x.2.N * h x.1) F.reduce).sum = (Multiset.map (fun x => ↑x.2.N * h x.1) F).sum⊢ F.reduce.anomalyCoefficient = F.anomalyCoefficient simpAll goals completed! 🐙𝓩:Typeinst✝¹:CommRing 𝓩F:FiveQuanta 𝓩inst✝:DecidableEq 𝓩h:𝓩 → 𝓩f:𝓩 → Fluxes →+ 𝓩 := fun q5 => { toFun := fun x => x.N • h q5, map_zero' := ⋯, map_add' := ⋯ }⊢ (Multiset.map (fun x => ↑x.2.N * h x.1) F.reduce).sum = (Multiset.map (fun x => ↑x.2.N * h x.1) F).sum𝓩:Typeinst✝¹:CommRing 𝓩F:FiveQuanta 𝓩inst✝:DecidableEq 𝓩reduce_sum_N_mul_eq:∀ (h : 𝓩 → 𝓩), (Multiset.map (fun x => ↑x.2.N * h x.1) F.reduce).sum = (Multiset.map (fun x => ↑x.2.N * h x.1) F).sum⊢ F.reduce.anomalyCoefficient = F.anomalyCoefficient
        map_add' := by𝓩:Typeinst✝¹:CommRing 𝓩F:FiveQuanta 𝓩inst✝:DecidableEq 𝓩h:𝓩 → 𝓩q5:𝓩⊢ ∀ (x y : Fluxes), (x + y).N • h q5 = x.N • h q5 + y.N • h q5𝓩:Typeinst✝¹:CommRing 𝓩F:FiveQuanta 𝓩inst✝:DecidableEq 𝓩h:𝓩 → 𝓩f:𝓩 → Fluxes →+ 𝓩 := fun q5 => { toFun := fun x => x.N • h q5, map_zero' := ⋯, map_add' := ⋯ }⊢ (Multiset.map (fun x => ↑x.2.N * h x.1) F.reduce).sum = (Multiset.map (fun x => ↑x.2.N * h x.1) F).sum𝓩:Typeinst✝¹:CommRing 𝓩F:FiveQuanta 𝓩inst✝:DecidableEq 𝓩reduce_sum_N_mul_eq:∀ (h : 𝓩 → 𝓩), (Multiset.map (fun x => ↑x.2.N * h x.1) F.reduce).sum = (Multiset.map (fun x => ↑x.2.N * h x.1) F).sum⊢ F.reduce.anomalyCoefficient = F.anomalyCoefficient
          intros x y𝓩:Typeinst✝¹:CommRing 𝓩F:FiveQuanta 𝓩inst✝:DecidableEq 𝓩h:𝓩 → 𝓩q5:𝓩x:Fluxesy:Fluxes⊢ (x + y).N • h q5 = x.N • h q5 + y.N • h q5𝓩:Typeinst✝¹:CommRing 𝓩F:FiveQuanta 𝓩inst✝:DecidableEq 𝓩h:𝓩 → 𝓩f:𝓩 → Fluxes →+ 𝓩 := fun q5 => { toFun := fun x => x.N • h q5, map_zero' := ⋯, map_add' := ⋯ }⊢ (Multiset.map (fun x => ↑x.2.N * h x.1) F.reduce).sum = (Multiset.map (fun x => ↑x.2.N * h x.1) F).sum𝓩:Typeinst✝¹:CommRing 𝓩F:FiveQuanta 𝓩inst✝:DecidableEq 𝓩reduce_sum_N_mul_eq:∀ (h : 𝓩 → 𝓩), (Multiset.map (fun x => ↑x.2.N * h x.1) F.reduce).sum = (Multiset.map (fun x => ↑x.2.N * h x.1) F).sum⊢ F.reduce.anomalyCoefficient = F.anomalyCoefficient
          simp [add_mul]All goals completed! 🐙𝓩:Typeinst✝¹:CommRing 𝓩F:FiveQuanta 𝓩inst✝:DecidableEq 𝓩h:𝓩 → 𝓩f:𝓩 → Fluxes →+ 𝓩 := fun q5 => { toFun := fun x => x.N • h q5, map_zero' := ⋯, map_add' := ⋯ }⊢ (Multiset.map (fun x => ↑x.2.N * h x.1) F.reduce).sum = (Multiset.map (fun x => ↑x.2.N * h x.1) F).sum𝓩:Typeinst✝¹:CommRing 𝓩F:FiveQuanta 𝓩inst✝:DecidableEq 𝓩reduce_sum_N_mul_eq:∀ (h : 𝓩 → 𝓩), (Multiset.map (fun x => ↑x.2.N * h x.1) F.reduce).sum = (Multiset.map (fun x => ↑x.2.N * h x.1) F).sum⊢ F.reduce.anomalyCoefficient = F.anomalyCoefficient }𝓩:Typeinst✝¹:CommRing 𝓩F:FiveQuanta 𝓩inst✝:DecidableEq 𝓩h:𝓩 → 𝓩f:𝓩 → Fluxes →+ 𝓩 := fun q5 => { toFun := fun x => x.N • h q5, map_zero' := ⋯, map_add' := ⋯ }⊢ (Multiset.map (fun x => ↑x.2.N * h x.1) F.reduce).sum = (Multiset.map (fun x => ↑x.2.N * h x.1) F).sum𝓩:Typeinst✝¹:CommRing 𝓩F:FiveQuanta 𝓩inst✝:DecidableEq 𝓩reduce_sum_N_mul_eq:∀ (h : 𝓩 → 𝓩), (Multiset.map (fun x => ↑x.2.N * h x.1) F.reduce).sum = (Multiset.map (fun x => ↑x.2.N * h x.1) F).sum⊢ F.reduce.anomalyCoefficient = F.anomalyCoefficient
    simpa [f] using reduce_sum_eq_sum_toCharges F f𝓩:Typeinst✝¹:CommRing 𝓩F:FiveQuanta 𝓩inst✝:DecidableEq 𝓩reduce_sum_N_mul_eq:∀ (h : 𝓩 → 𝓩), (Multiset.map (fun x => ↑x.2.N * h x.1) F.reduce).sum = (Multiset.map (fun x => ↑x.2.N * h x.1) F).sum⊢ F.reduce.anomalyCoefficient = F.anomalyCoefficient𝓩:Typeinst✝¹:CommRing 𝓩F:FiveQuanta 𝓩inst✝:DecidableEq 𝓩reduce_sum_N_mul_eq:∀ (h : 𝓩 → 𝓩), (Multiset.map (fun x => ↑x.2.N * h x.1) F.reduce).sum = (Multiset.map (fun x => ↑x.2.N * h x.1) F).sum⊢ F.reduce.anomalyCoefficient = F.anomalyCoefficient
  simp [anomalyCoefficient]𝓩:Typeinst✝¹:CommRing 𝓩F:FiveQuanta 𝓩inst✝:DecidableEq 𝓩reduce_sum_N_mul_eq:∀ (h : 𝓩 → 𝓩), (Multiset.map (fun x => ↑x.2.N * h x.1) F.reduce).sum = (Multiset.map (fun x => ↑x.2.N * h 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 ∧
  (Multiset.map (fun x => ↑x.2.N * (x.1 * x.1)) F.reduce).sum = (Multiset.map (fun x => ↑x.2.N * (x.1 * x.1)) F).sum
  exact ⟨reduce_sum_N_mul_eq fun q => q, reduce_sum_N_mul_eq fun q => q * q⟩All goals completed! 🐙

Quanta of 5-d representations

i. Overview

ii. Key results

iii. Table of contents

iv. References

A. The definition of FiveQuanta

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 FiveQuanta

B.1. The reduced FiveQuanta has no duplicate elements

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

B.3. Membership condition on the reduced FiveQuanta

B.4. Filter of the reduced FiveQuanta 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 FiveQuanta is a sum of fluxes in the original FiveQuanta

B.10. No exotics condition on the reduced FiveQuanta

B.10.1. Number of chiral L

B.10.2. Number of anti-chiral L

B.10.3. Number of chiral D

B.10.4. Number of anti-chiral D

B.10.5. The NoExotics condition on the reduced FiveQuanta

B.11. Reduce member of FluxesFive.elemsNoExotics

C. Decomposition of a FiveQuanta into basic fluxes

C.1. Decomposition of fluxes

C.2. Decomposition of a FiveQuanta (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 FiveQuanta

D. Lifting charges to FiveQuanta

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

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

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

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

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

D.6. FiveQuanta 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 FiveQuanta

E.2. Anomaly coefficients under a map

E.3. Anomaly coefficients is preserved under reduce

A. The definition of `FiveQuanta`

B. The reduction of a `FiveQuanta`

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

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

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

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

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

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

B.10.1. Number of chiral `L`

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

B.10.3. Number of chiral `D`

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

B.10.5. The `NoExotics` condition on the reduced `FiveQuanta`

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

C. Decomposition of a `FiveQuanta` into basic fluxes

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

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

D. Lifting charges to `FiveQuanta`

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

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

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

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

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

D.6. FiveQuanta 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 `FiveQuanta`

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