Theorem: HahnSeries.addOppositeEquiv_symm_apply_coeff
File: Mathlib/RingTheory/HahnSeries/Addition.lean

Proof steps:
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x : HahnSeries Γ Rᵃᵒᵖ
⊢ (Function.support fun a => AddOpposite.unop (x.coeff a)).IsPWO
state_after: case h.e'_3
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x : HahnSeries Γ Rᵃᵒᵖ
⊢ (Function.support fun a => AddOpposite.unop (x.coeff a)) = x.support
tactic: convert x.isPWO_support
state_before: case h.e'_3
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x : HahnSeries Γ Rᵃᵒᵖ
⊢ (Function.support fun a => AddOpposite.unop (x.coeff a)) = x.support
state_after: case h.e'_3.h
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x : HahnSeries Γ Rᵃᵒᵖ
x✝ : Γ
⊢ (x✝ ∈ Function.support fun a => AddOpposite.unop (x.coeff a)) ↔ x✝ ∈ x.support
tactic: ext
state_before: case h.e'_3.h
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x : HahnSeries Γ Rᵃᵒᵖ
x✝ : Γ
⊢ (x✝ ∈ Function.support fun a => AddOpposite.unop (x.coeff a)) ↔ x✝ ∈ x.support
state_after: no goals
tactic: simp
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x : (HahnSeries Γ R)ᵃᵒᵖ
⊢ (Function.support fun a => AddOpposite.op ((AddOpposite.unop x).coeff a)).IsPWO
state_after: case h.e'_3
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x : (HahnSeries Γ R)ᵃᵒᵖ
⊢ (Function.support fun a => AddOpposite.op ((AddOpposite.unop x).coeff a)) = (AddOpposite.unop x).support
tactic: convert x.unop.isPWO_support
state_before: case h.e'_3
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x : (HahnSeries Γ R)ᵃᵒᵖ
⊢ (Function.support fun a => AddOpposite.op ((AddOpposite.unop x).coeff a)) = (AddOpposite.unop x).support
state_after: case h.e'_3.h
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x : (HahnSeries Γ R)ᵃᵒᵖ
x✝ : Γ
⊢ (x✝ ∈ Function.support fun a => AddOpposite.op ((AddOpposite.unop x).coeff a)) ↔ x✝ ∈ (AddOpposite.unop x).support
tactic: ext
state_before: case h.e'_3.h
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x : (HahnSeries Γ R)ᵃᵒᵖ
x✝ : Γ
⊢ (x✝ ∈ Function.support fun a => AddOpposite.op ((AddOpposite.unop x).coeff a)) ↔ x✝ ∈ (AddOpposite.unop x).support
state_after: no goals
tactic: simp
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x : HahnSeries Γ Rᵃᵒᵖ
⊢ (fun x => { coeff := fun a => AddOpposite.op ((AddOpposite.unop x).coeff a), isPWO_support' := ⋯ })
      ((fun x => AddOpposite.op { coeff := fun a => AddOpposite.unop (x.coeff a), isPWO_support' := ⋯ }) x) =
    x
state_after: case coeff.h
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x : HahnSeries Γ Rᵃᵒᵖ
x✝ : Γ
⊢ ((fun x => { coeff := fun a => AddOpposite.op ((AddOpposite.unop x).coeff a), isPWO_support' := ⋯ })
          ((fun x => AddOpposite.op { coeff := fun a => AddOpposite.unop (x.coeff a), isPWO_support' := ⋯ }) x)).coeff
      x✝ =
    x.coeff x✝
tactic: ext
state_before: case coeff.h
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x : HahnSeries Γ Rᵃᵒᵖ
x✝ : Γ
⊢ ((fun x => { coeff := fun a => AddOpposite.op ((AddOpposite.unop x).coeff a), isPWO_support' := ⋯ })
          ((fun x => AddOpposite.op { coeff := fun a => AddOpposite.unop (x.coeff a), isPWO_support' := ⋯ }) x)).coeff
      x✝ =
    x.coeff x✝
state_after: no goals
tactic: simp
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x : (HahnSeries Γ R)ᵃᵒᵖ
⊢ (fun x => AddOpposite.op { coeff := fun a => AddOpposite.unop (x.coeff a), isPWO_support' := ⋯ })
      ((fun x => { coeff := fun a => AddOpposite.op ((AddOpposite.unop x).coeff a), isPWO_support' := ⋯ }) x) =
    x
state_after: case a
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x : (HahnSeries Γ R)ᵃᵒᵖ
⊢ AddOpposite.unop
      ((fun x => AddOpposite.op { coeff := fun a => AddOpposite.unop (x.coeff a), isPWO_support' := ⋯ })
        ((fun x => { coeff := fun a => AddOpposite.op ((AddOpposite.unop x).coeff a), isPWO_support' := ⋯ }) x)) =
    AddOpposite.unop x
tactic: apply AddOpposite.unop_injective
state_before: case a
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x : (HahnSeries Γ R)ᵃᵒᵖ
⊢ AddOpposite.unop
      ((fun x => AddOpposite.op { coeff := fun a => AddOpposite.unop (x.coeff a), isPWO_support' := ⋯ })
        ((fun x => { coeff := fun a => AddOpposite.op ((AddOpposite.unop x).coeff a), isPWO_support' := ⋯ }) x)) =
    AddOpposite.unop x
state_after: case a.coeff.h
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x : (HahnSeries Γ R)ᵃᵒᵖ
x✝ : Γ
⊢ (AddOpposite.unop
          ((fun x => AddOpposite.op { coeff := fun a => AddOpposite.unop (x.coeff a), isPWO_support' := ⋯ })
            ((fun x => { coeff := fun a => AddOpposite.op ((AddOpposite.unop x).coeff a), isPWO_support' := ⋯ })
              x))).coeff
      x✝ =
    (AddOpposite.unop x).coeff x✝
tactic: ext
state_before: case a.coeff.h
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x : (HahnSeries Γ R)ᵃᵒᵖ
x✝ : Γ
⊢ (AddOpposite.unop
          ((fun x => AddOpposite.op { coeff := fun a => AddOpposite.unop (x.coeff a), isPWO_support' := ⋯ })
            ((fun x => { coeff := fun a => AddOpposite.op ((AddOpposite.unop x).coeff a), isPWO_support' := ⋯ })
              x))).coeff
      x✝ =
    (AddOpposite.unop x).coeff x✝
state_after: no goals
tactic: simp
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x y : HahnSeries Γ Rᵃᵒᵖ
⊢ { toFun := fun x => AddOpposite.op { coeff := fun a => AddOpposite.unop (x.coeff a), isPWO_support' := ⋯ },
          invFun := fun x => { coeff := fun a => AddOpposite.op ((AddOpposite.unop x).coeff a), isPWO_support' := ⋯ },
          left_inv := ⋯, right_inv := ⋯ }.toFun
      (x + y) =
    { toFun := fun x => AddOpposite.op { coeff := fun a => AddOpposite.unop (x.coeff a), isPWO_support' := ⋯ },
            invFun := fun x => { coeff := fun a => AddOpposite.op ((AddOpposite.unop x).coeff a), isPWO_support' := ⋯ },
            left_inv := ⋯, right_inv := ⋯ }.toFun
        x +
      { toFun := fun x => AddOpposite.op { coeff := fun a => AddOpposite.unop (x.coeff a), isPWO_support' := ⋯ },
            invFun := fun x => { coeff := fun a => AddOpposite.op ((AddOpposite.unop x).coeff a), isPWO_support' := ⋯ },
            left_inv := ⋯, right_inv := ⋯ }.toFun
        y
state_after: case a
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x y : HahnSeries Γ Rᵃᵒᵖ
⊢ AddOpposite.unop
      ({ toFun := fun x => AddOpposite.op { coeff := fun a => AddOpposite.unop (x.coeff a), isPWO_support' := ⋯ },
            invFun := fun x => { coeff := fun a => AddOpposite.op ((AddOpposite.unop x).coeff a), isPWO_support' := ⋯ },
            left_inv := ⋯, right_inv := ⋯ }.toFun
        (x + y)) =
    AddOpposite.unop
      ({ toFun := fun x => AddOpposite.op { coeff := fun a => AddOpposite.unop (x.coeff a), isPWO_support' := ⋯ },
              invFun := fun x =>
                { coeff := fun a => AddOpposite.op ((AddOpposite.unop x).coeff a), isPWO_support' := ⋯ },
              left_inv := ⋯, right_inv := ⋯ }.toFun
          x +
        { toFun := fun x => AddOpposite.op { coeff := fun a => AddOpposite.unop (x.coeff a), isPWO_support' := ⋯ },
              invFun := fun x =>
                { coeff := fun a => AddOpposite.op ((AddOpposite.unop x).coeff a), isPWO_support' := ⋯ },
              left_inv := ⋯, right_inv := ⋯ }.toFun
          y)
tactic: apply AddOpposite.unop_injective
state_before: case a
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x y : HahnSeries Γ Rᵃᵒᵖ
⊢ AddOpposite.unop
      ({ toFun := fun x => AddOpposite.op { coeff := fun a => AddOpposite.unop (x.coeff a), isPWO_support' := ⋯ },
            invFun := fun x => { coeff := fun a => AddOpposite.op ((AddOpposite.unop x).coeff a), isPWO_support' := ⋯ },
            left_inv := ⋯, right_inv := ⋯ }.toFun
        (x + y)) =
    AddOpposite.unop
      ({ toFun := fun x => AddOpposite.op { coeff := fun a => AddOpposite.unop (x.coeff a), isPWO_support' := ⋯ },
              invFun := fun x =>
                { coeff := fun a => AddOpposite.op ((AddOpposite.unop x).coeff a), isPWO_support' := ⋯ },
              left_inv := ⋯, right_inv := ⋯ }.toFun
          x +
        { toFun := fun x => AddOpposite.op { coeff := fun a => AddOpposite.unop (x.coeff a), isPWO_support' := ⋯ },
              invFun := fun x =>
                { coeff := fun a => AddOpposite.op ((AddOpposite.unop x).coeff a), isPWO_support' := ⋯ },
              left_inv := ⋯, right_inv := ⋯ }.toFun
          y)
state_after: case a.coeff.h
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x y : HahnSeries Γ Rᵃᵒᵖ
x✝ : Γ
⊢ (AddOpposite.unop
          ({ toFun := fun x => AddOpposite.op { coeff := fun a => AddOpposite.unop (x.coeff a), isPWO_support' := ⋯ },
                invFun := fun x =>
                  { coeff := fun a => AddOpposite.op ((AddOpposite.unop x).coeff a), isPWO_support' := ⋯ },
                left_inv := ⋯, right_inv := ⋯ }.toFun
            (x + y))).coeff
      x✝ =
    (AddOpposite.unop
          ({ toFun := fun x => AddOpposite.op { coeff := fun a => AddOpposite.unop (x.coeff a), isPWO_support' := ⋯ },
                  invFun := fun x =>
                    { coeff := fun a => AddOpposite.op ((AddOpposite.unop x).coeff a), isPWO_support' := ⋯ },
                  left_inv := ⋯, right_inv := ⋯ }.toFun
              x +
            { toFun := fun x => AddOpposite.op { coeff := fun a => AddOpposite.unop (x.coeff a), isPWO_support' := ⋯ },
                  invFun := fun x =>
                    { coeff := fun a => AddOpposite.op ((AddOpposite.unop x).coeff a), isPWO_support' := ⋯ },
                  left_inv := ⋯, right_inv := ⋯ }.toFun
              y)).coeff
      x✝
tactic: ext
state_before: case a.coeff.h
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x y : HahnSeries Γ Rᵃᵒᵖ
x✝ : Γ
⊢ (AddOpposite.unop
          ({ toFun := fun x => AddOpposite.op { coeff := fun a => AddOpposite.unop (x.coeff a), isPWO_support' := ⋯ },
                invFun := fun x =>
                  { coeff := fun a => AddOpposite.op ((AddOpposite.unop x).coeff a), isPWO_support' := ⋯ },
                left_inv := ⋯, right_inv := ⋯ }.toFun
            (x + y))).coeff
      x✝ =
    (AddOpposite.unop
          ({ toFun := fun x => AddOpposite.op { coeff := fun a => AddOpposite.unop (x.coeff a), isPWO_support' := ⋯ },
                  invFun := fun x =>
                    { coeff := fun a => AddOpposite.op ((AddOpposite.unop x).coeff a), isPWO_support' := ⋯ },
                  left_inv := ⋯, right_inv := ⋯ }.toFun
              x +
            { toFun := fun x => AddOpposite.op { coeff := fun a => AddOpposite.unop (x.coeff a), isPWO_support' := ⋯ },
                  invFun := fun x =>
                    { coeff := fun a => AddOpposite.op ((AddOpposite.unop x).coeff a), isPWO_support' := ⋯ },
                  left_inv := ⋯, right_inv := ⋯ }.toFun
              y)).coeff
      x✝
state_after: no goals
tactic: simp