File: Mathlib/Combinatorics/Additive/ETransform.lean

full_name: Finset.mulDysonETransform_fst
code: /-- The **Dyson e-transform**. Turns `(s, t)` into `(s ∪ e • t, t ∩ e⁻¹ • s)`. This reduces the
product of the two sets. -/
@[to_additive (attr := simps) "The **Dyson e-transform**.
Turns `(s, t)` into `(s ∪ e +ᵥ t, t ∩ -e +ᵥ s)`. This reduces the sum of the two sets."]
def mulDysonETransform : Finset α × Finset α 
goal: (Finset.mulDysonETransform e x).1 = x.1 ∪ e • x.2

full_name: Finset.addDysonETransform
code: /-- The **Dyson e-transform**. Turns `(s, t)` into `(s ∪ e • t, t ∩ e⁻¹ • s)`. This reduces the
product of the two sets. -/
@[to_additive (attr := simps) "The **Dyson e-transform**.
Turns `(s, t)` into `(s ∪ e +ᵥ t, t ∩ -e +ᵥ s)`. This reduces the sum of the two sets."]
def mulDysonETransform : Finset α × Finset α 
goal: Finset α × Finset α

full_name: Finset.mulDysonETransform
code: /-- The **Dyson e-transform**. Turns `(s, t)` into `(s ∪ e • t, t ∩ e⁻¹ • s)`. This reduces the
product of the two sets. -/
@[to_additive (attr := simps) "The **Dyson e-transform**.
Turns `(s, t)` into `(s ∪ e +ᵥ t, t ∩ -e +ᵥ s)`. This reduces the sum of the two sets."]
def mulDysonETransform : Finset α × Finset α 
goal: Finset α × Finset α

full_name: Finset.addDysonETransform_snd
code: /-- The **Dyson e-transform**. Turns `(s, t)` into `(s ∪ e • t, t ∩ e⁻¹ • s)`. This reduces the
product of the two sets. -/
@[to_additive (attr := simps) "The **Dyson e-transform**.
Turns `(s, t)` into `(s ∪ e +ᵥ t, t ∩ -e +ᵥ s)`. This reduces the sum of the two sets."]
def mulDysonETransform : Finset α × Finset α 
goal: (Finset.addDysonETransform e x).2 = x.2 ∩ (-e +ᵥ x.1)

full_name: Finset.addDysonETransform_fst
code: /-- The **Dyson e-transform**. Turns `(s, t)` into `(s ∪ e • t, t ∩ e⁻¹ • s)`. This reduces the
product of the two sets. -/
@[to_additive (attr := simps) "The **Dyson e-transform**.
Turns `(s, t)` into `(s ∪ e +ᵥ t, t ∩ -e +ᵥ s)`. This reduces the sum of the two sets."]
def mulDysonETransform : Finset α × Finset α 
goal: (Finset.addDysonETransform e x).1 = x.1 ∪ (e +ᵥ x.2)

full_name: Finset.mulDysonETransform_snd
code: /-- The **Dyson e-transform**. Turns `(s, t)` into `(s ∪ e • t, t ∩ e⁻¹ • s)`. This reduces the
product of the two sets. -/
@[to_additive (attr := simps) "The **Dyson e-transform**.
Turns `(s, t)` into `(s ∪ e +ᵥ t, t ∩ -e +ᵥ s)`. This reduces the sum of the two sets."]
def mulDysonETransform : Finset α × Finset α 
goal: (Finset.mulDysonETransform e x).2 = x.2 ∩ e⁻¹ • x.1

full_name: Finset.mulDysonETransform.subset
code: @[to_additive]
theorem mulDysonETransform.subset :
    (mulDysonETransform e x).1 * (mulDysonETransform e x).2 ⊆ x.1 * x.2 
goal: (Finset.mulDysonETransform e x).1 * (Finset.mulDysonETransform e x).2 ⊆ x.1 * x.2

full_name: Finset.addDysonETransform.subset
code: @[to_additive]
theorem mulDysonETransform.subset :
    (mulDysonETransform e x).1 * (mulDysonETransform e x).2 ⊆ x.1 * x.2 
goal: (Finset.addDysonETransform e x).1 + (Finset.addDysonETransform e x).2 ⊆ x.1 + x.2

full_name: Finset.mulDysonETransform.card
code: @[to_additive]
theorem mulDysonETransform.card :
    (mulDysonETransform e x).1.card + (mulDysonETransform e x).2.card = x.1.card + x.2.card 
goal: (Finset.mulDysonETransform e x).1.card + (Finset.mulDysonETransform e x).2.card = x.1.card + x.2.card

full_name: Finset.addDysonETransform.card
code: @[to_additive]
theorem mulDysonETransform.card :
    (mulDysonETransform e x).1.card + (mulDysonETransform e x).2.card = x.1.card + x.2.card 
goal: (Finset.addDysonETransform e x).1.card + (Finset.addDysonETransform e x).2.card = x.1.card + x.2.card

full_name: Finset.addDysonETransform_idem
code: @[to_additive (attr := simp)]
theorem mulDysonETransform_idem :
    mulDysonETransform e (mulDysonETransform e x) = mulDysonETransform e x 
goal: Finset.addDysonETransform e (Finset.addDysonETransform e x) = Finset.addDysonETransform e x

full_name: Finset.mulDysonETransform_idem
code: @[to_additive (attr := simp)]
theorem mulDysonETransform_idem :
    mulDysonETransform e (mulDysonETransform e x) = mulDysonETransform e x 
goal: Finset.mulDysonETransform e (Finset.mulDysonETransform e x) = Finset.mulDysonETransform e x

full_name: Finset.mulDysonETransform.smul_finset_snd_subset_fst
code: @[to_additive]
theorem mulDysonETransform.smul_finset_snd_subset_fst :
    e • (mulDysonETransform e x).2 ⊆ (mulDysonETransform e x).1 
goal: e • (Finset.mulDysonETransform e x).2 ⊆ (Finset.mulDysonETransform e x).1

full_name: Finset.addDysonETransform.vadd_finset_snd_subset_fst
code: @[to_additive]
theorem mulDysonETransform.smul_finset_snd_subset_fst :
    e • (mulDysonETransform e x).2 ⊆ (mulDysonETransform e x).1 
goal: e +ᵥ (Finset.addDysonETransform e x).2 ⊆ (Finset.addDysonETransform e x).1

full_name: Finset.addETransformLeft_fst
code: /-- An **e-transform**. Turns `(s, t)` into `(s ∩ s • e, t ∪ e⁻¹ • t)`. This reduces the
product of the two sets. -/
@[to_additive (attr := simps) "An **e-transform**.
Turns `(s, t)` into `(s ∩ s +ᵥ e, t ∪ -e +ᵥ t)`. This reduces the sum of the two sets."]
def mulETransformLeft : Finset α × Finset α 
goal: (Finset.addETransformLeft e x).1 = x.1 ∩ (AddOpposite.op e +ᵥ x.1)

full_name: Finset.mulETransformLeft
code: /-- An **e-transform**. Turns `(s, t)` into `(s ∩ s • e, t ∪ e⁻¹ • t)`. This reduces the
product of the two sets. -/
@[to_additive (attr := simps) "An **e-transform**.
Turns `(s, t)` into `(s ∩ s +ᵥ e, t ∪ -e +ᵥ t)`. This reduces the sum of the two sets."]
def mulETransformLeft : Finset α × Finset α 
goal: Finset α × Finset α

full_name: Finset.mulETransformLeft_fst
code: /-- An **e-transform**. Turns `(s, t)` into `(s ∩ s • e, t ∪ e⁻¹ • t)`. This reduces the
product of the two sets. -/
@[to_additive (attr := simps) "An **e-transform**.
Turns `(s, t)` into `(s ∩ s +ᵥ e, t ∪ -e +ᵥ t)`. This reduces the sum of the two sets."]
def mulETransformLeft : Finset α × Finset α 
goal: (Finset.mulETransformLeft e x).1 = x.1 ∩ MulOpposite.op e • x.1

full_name: Finset.addETransformLeft
code: /-- An **e-transform**. Turns `(s, t)` into `(s ∩ s • e, t ∪ e⁻¹ • t)`. This reduces the
product of the two sets. -/
@[to_additive (attr := simps) "An **e-transform**.
Turns `(s, t)` into `(s ∩ s +ᵥ e, t ∪ -e +ᵥ t)`. This reduces the sum of the two sets."]
def mulETransformLeft : Finset α × Finset α 
goal: Finset α × Finset α

full_name: Finset.addETransformLeft_snd
code: /-- An **e-transform**. Turns `(s, t)` into `(s ∩ s • e, t ∪ e⁻¹ • t)`. This reduces the
product of the two sets. -/
@[to_additive (attr := simps) "An **e-transform**.
Turns `(s, t)` into `(s ∩ s +ᵥ e, t ∪ -e +ᵥ t)`. This reduces the sum of the two sets."]
def mulETransformLeft : Finset α × Finset α 
goal: (Finset.addETransformLeft e x).2 = x.2 ∪ (-e +ᵥ x.2)

full_name: Finset.mulETransformLeft_snd
code: /-- An **e-transform**. Turns `(s, t)` into `(s ∩ s • e, t ∪ e⁻¹ • t)`. This reduces the
product of the two sets. -/
@[to_additive (attr := simps) "An **e-transform**.
Turns `(s, t)` into `(s ∩ s +ᵥ e, t ∪ -e +ᵥ t)`. This reduces the sum of the two sets."]
def mulETransformLeft : Finset α × Finset α 
goal: (Finset.mulETransformLeft e x).2 = x.2 ∪ e⁻¹ • x.2

full_name: Finset.mulETransformRight_fst
code: /-- An **e-transform**. Turns `(s, t)` into `(s ∪ s • e, t ∩ e⁻¹ • t)`. This reduces the
product of the two sets. -/
@[to_additive (attr := simps) "An **e-transform**.
Turns `(s, t)` into `(s ∪ s +ᵥ e, t ∩ -e +ᵥ t)`. This reduces the sum of the two sets."]
def mulETransformRight : Finset α × Finset α 
goal: (Finset.mulETransformRight e x).1 = x.1 ∪ MulOpposite.op e • x.1

full_name: Finset.mulETransformRight_snd
code: /-- An **e-transform**. Turns `(s, t)` into `(s ∪ s • e, t ∩ e⁻¹ • t)`. This reduces the
product of the two sets. -/
@[to_additive (attr := simps) "An **e-transform**.
Turns `(s, t)` into `(s ∪ s +ᵥ e, t ∩ -e +ᵥ t)`. This reduces the sum of the two sets."]
def mulETransformRight : Finset α × Finset α 
goal: (Finset.mulETransformRight e x).2 = x.2 ∩ e⁻¹ • x.2

full_name: Finset.addETransformRight_snd
code: /-- An **e-transform**. Turns `(s, t)` into `(s ∪ s • e, t ∩ e⁻¹ • t)`. This reduces the
product of the two sets. -/
@[to_additive (attr := simps) "An **e-transform**.
Turns `(s, t)` into `(s ∪ s +ᵥ e, t ∩ -e +ᵥ t)`. This reduces the sum of the two sets."]
def mulETransformRight : Finset α × Finset α 
goal: (Finset.addETransformRight e x).2 = x.2 ∩ (-e +ᵥ x.2)

full_name: Finset.addETransformRight
code: /-- An **e-transform**. Turns `(s, t)` into `(s ∪ s • e, t ∩ e⁻¹ • t)`. This reduces the
product of the two sets. -/
@[to_additive (attr := simps) "An **e-transform**.
Turns `(s, t)` into `(s ∪ s +ᵥ e, t ∩ -e +ᵥ t)`. This reduces the sum of the two sets."]
def mulETransformRight : Finset α × Finset α 
goal: Finset α × Finset α

full_name: Finset.addETransformRight_fst
code: /-- An **e-transform**. Turns `(s, t)` into `(s ∪ s • e, t ∩ e⁻¹ • t)`. This reduces the
product of the two sets. -/
@[to_additive (attr := simps) "An **e-transform**.
Turns `(s, t)` into `(s ∪ s +ᵥ e, t ∩ -e +ᵥ t)`. This reduces the sum of the two sets."]
def mulETransformRight : Finset α × Finset α 
goal: (Finset.addETransformRight e x).1 = x.1 ∪ (AddOpposite.op e +ᵥ x.1)

full_name: Finset.mulETransformRight
code: /-- An **e-transform**. Turns `(s, t)` into `(s ∪ s • e, t ∩ e⁻¹ • t)`. This reduces the
product of the two sets. -/
@[to_additive (attr := simps) "An **e-transform**.
Turns `(s, t)` into `(s ∪ s +ᵥ e, t ∩ -e +ᵥ t)`. This reduces the sum of the two sets."]
def mulETransformRight : Finset α × Finset α 
goal: Finset α × Finset α

full_name: Finset.mulETransformLeft_one
code: @[to_additive (attr := simp)]
theorem mulETransformLeft_one : mulETransformLeft 1 x = x 
goal: Finset.mulETransformLeft 1 x = x

full_name: Finset.addETransformLeft_zero
code: @[to_additive (attr := simp)]
theorem mulETransformLeft_one : mulETransformLeft 1 x = x 
goal: Finset.addETransformLeft 0 x = x

full_name: Finset.mulETransformRight_one
code: @[to_additive (attr := simp)]
theorem mulETransformRight_one : mulETransformRight 1 x = x 
goal: Finset.mulETransformRight 1 x = x

full_name: Finset.addETransformRight_zero
code: @[to_additive (attr := simp)]
theorem mulETransformRight_one : mulETransformRight 1 x = x 
goal: Finset.addETransformRight 0 x = x

full_name: Finset.mulETransformLeft.fst_mul_snd_subset
code: @[to_additive]
theorem mulETransformLeft.fst_mul_snd_subset :
    (mulETransformLeft e x).1 * (mulETransformLeft e x).2 ⊆ x.1 * x.2 
goal: (Finset.mulETransformLeft e x).1 * (Finset.mulETransformLeft e x).2 ⊆ x.1 * x.2

full_name: Finset.addETransformLeft.fst_add_snd_subset
code: @[to_additive]
theorem mulETransformLeft.fst_mul_snd_subset :
    (mulETransformLeft e x).1 * (mulETransformLeft e x).2 ⊆ x.1 * x.2 
goal: (Finset.addETransformLeft e x).1 + (Finset.addETransformLeft e x).2 ⊆ x.1 + x.2

full_name: Finset.mulETransformRight.fst_mul_snd_subset
code: @[to_additive]
theorem mulETransformRight.fst_mul_snd_subset :
    (mulETransformRight e x).1 * (mulETransformRight e x).2 ⊆ x.1 * x.2 
goal: (Finset.mulETransformRight e x).1 * (Finset.mulETransformRight e x).2 ⊆ x.1 * x.2

full_name: Finset.addETransformRight.fst_add_snd_subset
code: @[to_additive]
theorem mulETransformRight.fst_mul_snd_subset :
    (mulETransformRight e x).1 * (mulETransformRight e x).2 ⊆ x.1 * x.2 
goal: (Finset.addETransformRight e x).1 + (Finset.addETransformRight e x).2 ⊆ x.1 + x.2

full_name: Finset.addETransformLeft.card
code: @[to_additive]
theorem mulETransformLeft.card :
    (mulETransformLeft e x).1.card + (mulETransformRight e x).1.card = 2 * x.1.card 
goal: (Finset.addETransformLeft e x).1.card + (Finset.addETransformRight e x).1.card = 2 * x.1.card

full_name: Finset.mulETransformLeft.card
code: @[to_additive]
theorem mulETransformLeft.card :
    (mulETransformLeft e x).1.card + (mulETransformRight e x).1.card = 2 * x.1.card 
goal: (Finset.mulETransformLeft e x).1.card + (Finset.mulETransformRight e x).1.card = 2 * x.1.card

full_name: Finset.mulETransformRight.card
code: @[to_additive]
theorem mulETransformRight.card :
    (mulETransformLeft e x).2.card + (mulETransformRight e x).2.card = 2 * x.2.card 
goal: (Finset.mulETransformLeft e x).2.card + (Finset.mulETransformRight e x).2.card = 2 * x.2.card

full_name: Finset.addETransformRight.card
code: @[to_additive]
theorem mulETransformRight.card :
    (mulETransformLeft e x).2.card + (mulETransformRight e x).2.card = 2 * x.2.card 
goal: (Finset.addETransformLeft e x).2.card + (Finset.addETransformRight e x).2.card = 2 * x.2.card

full_name: Finset.AddETransform.card
code: /-- This statement is meant to be combined with `le_or_lt_of_add_le_add` and similar lemmas. -/
@[to_additive AddETransform.card "This statement is meant to be combined with
`le_or_lt_of_add_le_add` and similar lemmas."]
protected theorem MulETransform.card :
    (mulETransformLeft e x).1.card + (mulETransformLeft e x).2.card +
        ((mulETransformRight e x).1.card + (mulETransformRight e x).2.card) =
      x.1.card + x.2.card + (x.1.card + x.2.card) 
goal: (Finset.addETransformLeft e x).1.card + (Finset.addETransformLeft e x).2.card +
    ((Finset.addETransformRight e x).1.card + (Finset.addETransformRight e x).2.card) =
  x.1.card + x.2.card + (x.1.card + x.2.card)

full_name: Finset.MulETransform.card
code: /-- This statement is meant to be combined with `le_or_lt_of_add_le_add` and similar lemmas. -/
@[to_additive AddETransform.card "This statement is meant to be combined with
`le_or_lt_of_add_le_add` and similar lemmas."]
protected theorem MulETransform.card :
    (mulETransformLeft e x).1.card + (mulETransformLeft e x).2.card +
        ((mulETransformRight e x).1.card + (mulETransformRight e x).2.card) =
      x.1.card + x.2.card + (x.1.card + x.2.card) 
goal: (Finset.mulETransformLeft e x).1.card + (Finset.mulETransformLeft e x).2.card +
    ((Finset.mulETransformRight e x).1.card + (Finset.mulETransformRight e x).2.card) =
  x.1.card + x.2.card + (x.1.card + x.2.card)

full_name: Finset.addETransformLeft_neg
code: @[to_additive (attr := simp)]
theorem mulETransformLeft_inv : mulETransformLeft e⁻¹ x = (mulETransformRight e x.swap).swap 
goal: Finset.addETransformLeft (-e) x = (Finset.addETransformRight e x.swap).swap

full_name: Finset.mulETransformLeft_inv
code: @[to_additive (attr := simp)]
theorem mulETransformLeft_inv : mulETransformLeft e⁻¹ x = (mulETransformRight e x.swap).swap 
goal: Finset.mulETransformLeft e⁻¹ x = (Finset.mulETransformRight e x.swap).swap

full_name: Finset.mulETransformRight_inv
code: @[to_additive (attr := simp)]
theorem mulETransformRight_inv : mulETransformRight e⁻¹ x = (mulETransformLeft e x.swap).swap 
goal: Finset.mulETransformRight e⁻¹ x = (Finset.mulETransformLeft e x.swap).swap

full_name: Finset.addETransformRight_neg
code: @[to_additive (attr := simp)]
theorem mulETransformRight_inv : mulETransformRight e⁻¹ x = (mulETransformLeft e x.swap).swap 
goal: Finset.addETransformRight (-e) x = (Finset.addETransformLeft e x.swap).swap