l3lab/ntp-mathlib huggingface dataset:
set_option synthInstance.maxHeartbeats 30000 in
/-- The representation of the clifford conjugate (i.e. the reverse of the involute) in the even
subalgebra is just the reverse of the representation. -/
theorem coe_toEven_reverse_involute (x : CliffordAlgebra Q) :
    ↑(toEven Q (reverse (involute x))) =
      reverse (Q := Q' Q) (toEven Q x : CliffordAlgebra (Q' Q)) := by
  induction x using CliffordAlgebra.induction
  

Proof state:
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
r : R
⊢ ↑((toEven Q) (reverse (involute ((algebraMap R (CliffordAlgebra Q)) r)))) =
    reverse ↑((toEven Q) ((algebraMap R (CliffordAlgebra Q)) r))

Next tactic:
case h_grade0 r => simp only [AlgHom.commutes, Subalgebra.coe_algebraMap, reverse.commutes]
set_option synthInstance.maxHeartbeats 30000 in
/-- The representation of the clifford conjugate (i.e. the reverse of the involute) in the even
subalgebra is just the reverse of the representation. -/
theorem coe_toEven_reverse_involute (x : CliffordAlgebra Q) :
    ↑(toEven Q (reverse (involute x))) =
      reverse (Q := Q' Q) (toEven Q x : CliffordAlgebra (Q' Q)) := by
  induction x using CliffordAlgebra.induction
  case h_grade0 r => 

Proof state:
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
r : R
⊢ ↑((toEven Q) (reverse (involute ((algebraMap R (CliffordAlgebra Q)) r)))) =
    reverse ↑((toEven Q) ((algebraMap R (CliffordAlgebra Q)) r))

Next tactic:
simp only [AlgHom.commutes, Subalgebra.coe_algebraMap, reverse.commutes]
set_option synthInstance.maxHeartbeats 30000 in
/-- The representation of the clifford conjugate (i.e. the reverse of the involute) in the even
subalgebra is just the reverse of the representation. -/
theorem coe_toEven_reverse_involute (x : CliffordAlgebra Q) :
    ↑(toEven Q (reverse (involute x))) =
      reverse (Q := Q' Q) (toEven Q x : CliffordAlgebra (Q' Q)) := by
  induction x using CliffordAlgebra.induction
  case h_grade0 r => simp only [AlgHom.commutes, Subalgebra.coe_algebraMap, reverse.commutes]
  

Proof state:
case h_grade1
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
x✝ : M
⊢ ↑((toEven Q) (reverse (involute ((ι Q) x✝)))) = reverse ↑((toEven Q) ((ι Q) x✝))
case h_mul
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
a✝² b✝ : CliffordAlgebra Q
a✝¹ : ↑((toEven Q) (reverse (involute a✝²))) = reverse ↑((toEven Q) a✝²)
a✝ : ↑((toEven Q) (reverse (involute b✝))) = reverse ↑((toEven Q) b✝)
⊢ ↑((toEven Q) (reverse (involute (a✝² * b✝)))) = reverse ↑((toEven Q) (a✝² * b✝))
case h_add
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
a✝² b✝ : CliffordAlgebra Q
a✝¹ : ↑((toEven Q) (reverse (involute a✝²))) = reverse ↑((toEven Q) a✝²)
a✝ : ↑((toEven Q) (reverse (involute b✝))) = reverse ↑((toEven Q) b✝)
⊢ ↑((toEven Q) (reverse (involute (a✝² + b✝)))) = reverse ↑((toEven Q) (a✝² + b✝))

Next tactic:
case h_grade1 m =>
    -- porting note: added `letI`
    letI : SubtractionMonoid (even (Q' Q)) := AddGroup.toSubtractionMonoid
    simp only [involute_ι, Subalgebra.coe_neg, toEven_ι, reverse.map_mul, reverse_v, reverse_e0,
      reverse_ι, neg_e0_mul_v, map_neg]
set_option synthInstance.maxHeartbeats 30000 in
/-- The representation of the clifford conjugate (i.e. the reverse of the involute) in the even
subalgebra is just the reverse of the representation. -/
theorem coe_toEven_reverse_involute (x : CliffordAlgebra Q) :
    ↑(toEven Q (reverse (involute x))) =
      reverse (Q := Q' Q) (toEven Q x : CliffordAlgebra (Q' Q)) := by
  induction x using CliffordAlgebra.induction
  case h_grade0 r => simp only [AlgHom.commutes, Subalgebra.coe_algebraMap, reverse.commutes]
  

Proof state:
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
m : M
⊢ ↑((toEven Q) (reverse (involute ((ι Q) m)))) = reverse ↑((toEven Q) ((ι Q) m))

Next tactic:
case h_grade1 m =>
    -- porting note: added `letI`
    letI : SubtractionMonoid (even (Q' Q)) := AddGroup.toSubtractionMonoid
    simp only [involute_ι, Subalgebra.coe_neg, toEven_ι, reverse.map_mul, reverse_v, reverse_e0,
      reverse_ι, neg_e0_mul_v, map_neg]
set_option synthInstance.maxHeartbeats 30000 in
/-- The representation of the clifford conjugate (i.e. the reverse of the involute) in the even
subalgebra is just the reverse of the representation. -/
theorem coe_toEven_reverse_involute (x : CliffordAlgebra Q) :
    ↑(toEven Q (reverse (involute x))) =
      reverse (Q := Q' Q) (toEven Q x : CliffordAlgebra (Q' Q)) := by
  induction x using CliffordAlgebra.induction
  case h_grade0 r => simp only [AlgHom.commutes, Subalgebra.coe_algebraMap, reverse.commutes]
  case h_grade1 m =>
    -- porting note: added `letI`
    

Proof state:
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
m : M
⊢ ↑((toEven Q) (reverse (involute ((ι Q) m)))) = reverse ↑((toEven Q) ((ι Q) m))

Next tactic:
letI : SubtractionMonoid (even (Q' Q)) := AddGroup.toSubtractionMonoid
set_option synthInstance.maxHeartbeats 30000 in
/-- The representation of the clifford conjugate (i.e. the reverse of the involute) in the even
subalgebra is just the reverse of the representation. -/
theorem coe_toEven_reverse_involute (x : CliffordAlgebra Q) :
    ↑(toEven Q (reverse (involute x))) =
      reverse (Q := Q' Q) (toEven Q x : CliffordAlgebra (Q' Q)) := by
  induction x using CliffordAlgebra.induction
  case h_grade0 r => simp only [AlgHom.commutes, Subalgebra.coe_algebraMap, reverse.commutes]
  case h_grade1 m =>
    -- porting note: added `letI`
    letI : SubtractionMonoid (even (Q' Q)) := AddGroup.toSubtractionMonoid
    

Proof state:
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
m : M
this : SubtractionMonoid ↥(even (Q' Q)) := AddGroup.toSubtractionMonoid
⊢ ↑((toEven Q) (reverse (involute ((ι Q) m)))) = reverse ↑((toEven Q) ((ι Q) m))

Next tactic:
simp only [involute_ι, Subalgebra.coe_neg, toEven_ι, reverse.map_mul, reverse_v, reverse_e0,
      reverse_ι, neg_e0_mul_v, map_neg]
set_option synthInstance.maxHeartbeats 30000 in
/-- The representation of the clifford conjugate (i.e. the reverse of the involute) in the even
subalgebra is just the reverse of the representation. -/
theorem coe_toEven_reverse_involute (x : CliffordAlgebra Q) :
    ↑(toEven Q (reverse (involute x))) =
      reverse (Q := Q' Q) (toEven Q x : CliffordAlgebra (Q' Q)) := by
  induction x using CliffordAlgebra.induction
  case h_grade0 r => simp only [AlgHom.commutes, Subalgebra.coe_algebraMap, reverse.commutes]
  case h_grade1 m =>
    -- porting note: added `letI`
    letI : SubtractionMonoid (even (Q' Q)) := AddGroup.toSubtractionMonoid
    simp only [involute_ι, Subalgebra.coe_neg, toEven_ι, reverse.map_mul, reverse_v, reverse_e0,
      reverse_ι, neg_e0_mul_v, map_neg]
  

Proof state:
case h_mul
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
a✝² b✝ : CliffordAlgebra Q
a✝¹ : ↑((toEven Q) (reverse (involute a✝²))) = reverse ↑((toEven Q) a✝²)
a✝ : ↑((toEven Q) (reverse (involute b✝))) = reverse ↑((toEven Q) b✝)
⊢ ↑((toEven Q) (reverse (involute (a✝² * b✝)))) = reverse ↑((toEven Q) (a✝² * b✝))
case h_add
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
a✝² b✝ : CliffordAlgebra Q
a✝¹ : ↑((toEven Q) (reverse (involute a✝²))) = reverse ↑((toEven Q) a✝²)
a✝ : ↑((toEven Q) (reverse (involute b✝))) = reverse ↑((toEven Q) b✝)
⊢ ↑((toEven Q) (reverse (involute (a✝² + b✝)))) = reverse ↑((toEven Q) (a✝² + b✝))

Next tactic:
case h_mul x y hx hy => simp only [map_mul, Subalgebra.coe_mul, reverse.map_mul, hx, hy]
set_option synthInstance.maxHeartbeats 30000 in
/-- The representation of the clifford conjugate (i.e. the reverse of the involute) in the even
subalgebra is just the reverse of the representation. -/
theorem coe_toEven_reverse_involute (x : CliffordAlgebra Q) :
    ↑(toEven Q (reverse (involute x))) =
      reverse (Q := Q' Q) (toEven Q x : CliffordAlgebra (Q' Q)) := by
  induction x using CliffordAlgebra.induction
  case h_grade0 r => simp only [AlgHom.commutes, Subalgebra.coe_algebraMap, reverse.commutes]
  case h_grade1 m =>
    -- porting note: added `letI`
    letI : SubtractionMonoid (even (Q' Q)) := AddGroup.toSubtractionMonoid
    simp only [involute_ι, Subalgebra.coe_neg, toEven_ι, reverse.map_mul, reverse_v, reverse_e0,
      reverse_ι, neg_e0_mul_v, map_neg]
  

Proof state:
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
x y : CliffordAlgebra Q
hx : ↑((toEven Q) (reverse (involute x))) = reverse ↑((toEven Q) x)
hy : ↑((toEven Q) (reverse (involute y))) = reverse ↑((toEven Q) y)
⊢ ↑((toEven Q) (reverse (involute (x * y)))) = reverse ↑((toEven Q) (x * y))

Next tactic:
case h_mul x y hx hy => simp only [map_mul, Subalgebra.coe_mul, reverse.map_mul, hx, hy]
set_option synthInstance.maxHeartbeats 30000 in
/-- The representation of the clifford conjugate (i.e. the reverse of the involute) in the even
subalgebra is just the reverse of the representation. -/
theorem coe_toEven_reverse_involute (x : CliffordAlgebra Q) :
    ↑(toEven Q (reverse (involute x))) =
      reverse (Q := Q' Q) (toEven Q x : CliffordAlgebra (Q' Q)) := by
  induction x using CliffordAlgebra.induction
  case h_grade0 r => simp only [AlgHom.commutes, Subalgebra.coe_algebraMap, reverse.commutes]
  case h_grade1 m =>
    -- porting note: added `letI`
    letI : SubtractionMonoid (even (Q' Q)) := AddGroup.toSubtractionMonoid
    simp only [involute_ι, Subalgebra.coe_neg, toEven_ι, reverse.map_mul, reverse_v, reverse_e0,
      reverse_ι, neg_e0_mul_v, map_neg]
  case h_mul x y hx hy => 

Proof state:
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
x y : CliffordAlgebra Q
hx : ↑((toEven Q) (reverse (involute x))) = reverse ↑((toEven Q) x)
hy : ↑((toEven Q) (reverse (involute y))) = reverse ↑((toEven Q) y)
⊢ ↑((toEven Q) (reverse (involute (x * y)))) = reverse ↑((toEven Q) (x * y))

Next tactic:
simp only [map_mul, Subalgebra.coe_mul, reverse.map_mul, hx, hy]
set_option synthInstance.maxHeartbeats 30000 in
/-- The representation of the clifford conjugate (i.e. the reverse of the involute) in the even
subalgebra is just the reverse of the representation. -/
theorem coe_toEven_reverse_involute (x : CliffordAlgebra Q) :
    ↑(toEven Q (reverse (involute x))) =
      reverse (Q := Q' Q) (toEven Q x : CliffordAlgebra (Q' Q)) := by
  induction x using CliffordAlgebra.induction
  case h_grade0 r => simp only [AlgHom.commutes, Subalgebra.coe_algebraMap, reverse.commutes]
  case h_grade1 m =>
    -- porting note: added `letI`
    letI : SubtractionMonoid (even (Q' Q)) := AddGroup.toSubtractionMonoid
    simp only [involute_ι, Subalgebra.coe_neg, toEven_ι, reverse.map_mul, reverse_v, reverse_e0,
      reverse_ι, neg_e0_mul_v, map_neg]
  case h_mul x y hx hy => simp only [map_mul, Subalgebra.coe_mul, reverse.map_mul, hx, hy]
  

Proof state:
case h_add
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
a✝² b✝ : CliffordAlgebra Q
a✝¹ : ↑((toEven Q) (reverse (involute a✝²))) = reverse ↑((toEven Q) a✝²)
a✝ : ↑((toEven Q) (reverse (involute b✝))) = reverse ↑((toEven Q) b✝)
⊢ ↑((toEven Q) (reverse (involute (a✝² + b✝)))) = reverse ↑((toEven Q) (a✝² + b✝))

Next tactic:
case h_add x y hx hy => simp only [map_add, Subalgebra.coe_add, hx, hy]
set_option synthInstance.maxHeartbeats 30000 in
/-- The representation of the clifford conjugate (i.e. the reverse of the involute) in the even
subalgebra is just the reverse of the representation. -/
theorem coe_toEven_reverse_involute (x : CliffordAlgebra Q) :
    ↑(toEven Q (reverse (involute x))) =
      reverse (Q := Q' Q) (toEven Q x : CliffordAlgebra (Q' Q)) := by
  induction x using CliffordAlgebra.induction
  case h_grade0 r => simp only [AlgHom.commutes, Subalgebra.coe_algebraMap, reverse.commutes]
  case h_grade1 m =>
    -- porting note: added `letI`
    letI : SubtractionMonoid (even (Q' Q)) := AddGroup.toSubtractionMonoid
    simp only [involute_ι, Subalgebra.coe_neg, toEven_ι, reverse.map_mul, reverse_v, reverse_e0,
      reverse_ι, neg_e0_mul_v, map_neg]
  case h_mul x y hx hy => simp only [map_mul, Subalgebra.coe_mul, reverse.map_mul, hx, hy]
  

Proof state:
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
x y : CliffordAlgebra Q
hx : ↑((toEven Q) (reverse (involute x))) = reverse ↑((toEven Q) x)
hy : ↑((toEven Q) (reverse (involute y))) = reverse ↑((toEven Q) y)
⊢ ↑((toEven Q) (reverse (involute (x + y)))) = reverse ↑((toEven Q) (x + y))

Next tactic:
case h_add x y hx hy => simp only [map_add, Subalgebra.coe_add, hx, hy]
set_option synthInstance.maxHeartbeats 30000 in
/-- The representation of the clifford conjugate (i.e. the reverse of the involute) in the even
subalgebra is just the reverse of the representation. -/
theorem coe_toEven_reverse_involute (x : CliffordAlgebra Q) :
    ↑(toEven Q (reverse (involute x))) =
      reverse (Q := Q' Q) (toEven Q x : CliffordAlgebra (Q' Q)) := by
  induction x using CliffordAlgebra.induction
  case h_grade0 r => simp only [AlgHom.commutes, Subalgebra.coe_algebraMap, reverse.commutes]
  case h_grade1 m =>
    -- porting note: added `letI`
    letI : SubtractionMonoid (even (Q' Q)) := AddGroup.toSubtractionMonoid
    simp only [involute_ι, Subalgebra.coe_neg, toEven_ι, reverse.map_mul, reverse_v, reverse_e0,
      reverse_ι, neg_e0_mul_v, map_neg]
  case h_mul x y hx hy => simp only [map_mul, Subalgebra.coe_mul, reverse.map_mul, hx, hy]
  case h_add x y hx hy => 

Proof state:
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
x y : CliffordAlgebra Q
hx : ↑((toEven Q) (reverse (involute x))) = reverse ↑((toEven Q) x)
hy : ↑((toEven Q) (reverse (involute y))) = reverse ↑((toEven Q) y)
⊢ ↑((toEven Q) (reverse (involute (x + y)))) = reverse ↑((toEven Q) (x + y))

Next tactic:
simp only [map_add, Subalgebra.coe_add, hx, hy]
set_option synthInstance.maxHeartbeats 30000 in
/-- One direction of `CliffordAlgebra.evenEquivEvenNeg` -/
def evenToNeg (Q' : QuadraticForm R M) (h : Q' = -Q) :
    CliffordAlgebra.even Q →ₐ[R] CliffordAlgebra.even Q' :=
  even.lift Q <|
    -- porting note: added `letI`s
    letI : AddCommGroup (even Q') := AddSubgroupClass.toAddCommGroup _;
    letI : HasDistribNeg (even Q') := NonUnitalNonAssocRing.toHasDistribNeg;
    { bilin := -(even.ι Q' : _).bilin
      contract := fun m => by
        

Proof state:
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q Q' : QuadraticForm R M
h : Q' = -Q
this✝ : AddCommGroup ↥(even Q') := AddSubgroupClass.toAddCommGroup (even Q')
this : HasDistribNeg ↥(even Q') := NonUnitalNonAssocRing.toHasDistribNeg
m : M
⊢ ((-(even.ι Q').bilin) m) m = (algebraMap R ↥(even Q')) (Q m)

Next tactic:
simp_rw [LinearMap.neg_apply, EvenHom.contract, h, QuadraticForm.neg_apply, map_neg,
          neg_neg]
set_option synthInstance.maxHeartbeats 30000 in
/-- One direction of `CliffordAlgebra.evenEquivEvenNeg` -/
def evenToNeg (Q' : QuadraticForm R M) (h : Q' = -Q) :
    CliffordAlgebra.even Q →ₐ[R] CliffordAlgebra.even Q' :=
  even.lift Q <|
    -- porting note: added `letI`s
    letI : AddCommGroup (even Q') := AddSubgroupClass.toAddCommGroup _;
    letI : HasDistribNeg (even Q') := NonUnitalNonAssocRing.toHasDistribNeg;
    { bilin := -(even.ι Q' : _).bilin
      contract := fun m => by
        simp_rw [LinearMap.neg_apply, EvenHom.contract, h, QuadraticForm.neg_apply, map_neg,
          neg_neg]
      contract_mid := fun m₁ m₂ m₃ => by
        

Proof state:
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q Q' : QuadraticForm R M
h : Q' = -Q
this✝ : AddCommGroup ↥(even Q') := AddSubgroupClass.toAddCommGroup (even Q')
this : HasDistribNeg ↥(even Q') := NonUnitalNonAssocRing.toHasDistribNeg
m₁ m₂ m₃ : M
⊢ ((-(even.ι Q').bilin) m₁) m₂ * ((-(even.ι Q').bilin) m₂) m₃ = Q m₂ • ((-(even.ι Q').bilin) m₁) m₃

Next tactic:
simp_rw [LinearMap.neg_apply, neg_mul_neg, EvenHom.contract_mid, h,
          QuadraticForm.neg_apply, smul_neg, neg_smul]
set_option synthInstance.maxHeartbeats 100000 in
theorem evenToNeg_comp_evenToNeg (Q' : QuadraticForm R M) (h : Q' = -Q) (h' : Q = -Q') :
    (evenToNeg Q' Q h').comp (evenToNeg Q Q' h) = AlgHom.id R _ := by
  

Proof state:
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q Q' : QuadraticForm R M
h : Q' = -Q
h' : Q = -Q'
⊢ AlgHom.comp (evenToNeg Q' Q h') (evenToNeg Q Q' h) = AlgHom.id R ↥(even Q)

Next tactic:
ext m₁ m₂ : 4
set_option synthInstance.maxHeartbeats 100000 in
theorem evenToNeg_comp_evenToNeg (Q' : QuadraticForm R M) (h : Q' = -Q) (h' : Q = -Q') :
    (evenToNeg Q' Q h').comp (evenToNeg Q Q' h) = AlgHom.id R _ := by
  ext m₁ m₂ : 4
  

Proof state:
case h.bilin.h.h
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q Q' : QuadraticForm R M
h : Q' = -Q
h' : Q = -Q'
m₁ m₂ : M
⊢ ((EvenHom.compr₂ (even.ι Q) (AlgHom.comp (evenToNeg Q' Q h') (evenToNeg Q Q' h))).bilin m₁) m₂ =
    ((EvenHom.compr₂ (even.ι Q) (AlgHom.id R ↥(even Q))).bilin m₁) m₂

Next tactic:
dsimp only [EvenHom.compr₂_bilin, LinearMap.compr₂_apply, AlgHom.toLinearMap_apply,
    AlgHom.comp_apply, AlgHom.id_apply]
set_option synthInstance.maxHeartbeats 100000 in
theorem evenToNeg_comp_evenToNeg (Q' : QuadraticForm R M) (h : Q' = -Q) (h' : Q = -Q') :
    (evenToNeg Q' Q h').comp (evenToNeg Q Q' h) = AlgHom.id R _ := by
  ext m₁ m₂ : 4
  dsimp only [EvenHom.compr₂_bilin, LinearMap.compr₂_apply, AlgHom.toLinearMap_apply,
    AlgHom.comp_apply, AlgHom.id_apply]
  

Proof state:
case h.bilin.h.h
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q Q' : QuadraticForm R M
h : Q' = -Q
h' : Q = -Q'
m₁ m₂ : M
⊢ (evenToNeg Q' Q h') ((evenToNeg Q Q' h) (((even.ι Q).bilin m₁) m₂)) = ((even.ι Q).bilin m₁) m₂

Next tactic:
rw [evenToNeg_ι, map_neg, evenToNeg_ι, neg_neg]
attribute [ext] TensorProduct.ext in
/-- A tensor product of symmetric bilinear forms is symmetric. -/
lemma IsSymm.tmul {B₁ : BilinForm A M₁} {B₂ : BilinForm R M₂}
    (hB₁ : B₁.IsSymm) (hB₂ : B₂.IsSymm) : (B₁.tmul B₂).IsSymm := by
  

Proof state:
ι : Type uι
R : Type uR
A : Type uA
M₁ : Type uM₁
M₂ : Type uM₂
inst✝¹⁰ : CommSemiring R
inst✝⁹ : CommSemiring A
inst✝⁸ : AddCommMonoid M₁
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : Algebra R A
inst✝⁵ : Module R M₁
inst✝⁴ : Module A M₁
inst✝³ : SMulCommClass R A M₁
inst✝² : SMulCommClass A R M₁
inst✝¹ : IsScalarTower R A M₁
inst✝ : Module R M₂
B₁ : BilinForm A M₁
B₂ : BilinForm R M₂
hB₁ : IsSymm B₁
hB₂ : IsSymm B₂
⊢ IsSymm (BilinForm.tmul B₁ B₂)

Next tactic:
rw [isSymm_iff_flip R]
attribute [ext] TensorProduct.ext in
/-- A tensor product of symmetric bilinear forms is symmetric. -/
lemma IsSymm.tmul {B₁ : BilinForm A M₁} {B₂ : BilinForm R M₂}
    (hB₁ : B₁.IsSymm) (hB₂ : B₂.IsSymm) : (B₁.tmul B₂).IsSymm := by
  rw [isSymm_iff_flip R]
  

Proof state:
ι : Type uι
R : Type uR
A : Type uA
M₁ : Type uM₁
M₂ : Type uM₂
inst✝¹⁰ : CommSemiring R
inst✝⁹ : CommSemiring A
inst✝⁸ : AddCommMonoid M₁
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : Algebra R A
inst✝⁵ : Module R M₁
inst✝⁴ : Module A M₁
inst✝³ : SMulCommClass R A M₁
inst✝² : SMulCommClass A R M₁
inst✝¹ : IsScalarTower R A M₁
inst✝ : Module R M₂
B₁ : BilinForm A M₁
B₂ : BilinForm R M₂
hB₁ : IsSymm B₁
hB₂ : IsSymm B₂
⊢ (flipHom R) (BilinForm.tmul B₁ B₂) = BilinForm.tmul B₁ B₂

Next tactic:
apply toLin.injective
attribute [ext] TensorProduct.ext in
/-- A tensor product of symmetric bilinear forms is symmetric. -/
lemma IsSymm.tmul {B₁ : BilinForm A M₁} {B₂ : BilinForm R M₂}
    (hB₁ : B₁.IsSymm) (hB₂ : B₂.IsSymm) : (B₁.tmul B₂).IsSymm := by
  rw [isSymm_iff_flip R]
  apply toLin.injective
  

Proof state:
case a
ι : Type uι
R : Type uR
A : Type uA
M₁ : Type uM₁
M₂ : Type uM₂
inst✝¹⁰ : CommSemiring R
inst✝⁹ : CommSemiring A
inst✝⁸ : AddCommMonoid M₁
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : Algebra R A
inst✝⁵ : Module R M₁
inst✝⁴ : Module A M₁
inst✝³ : SMulCommClass R A M₁
inst✝² : SMulCommClass A R M₁
inst✝¹ : IsScalarTower R A M₁
inst✝ : Module R M₂
B₁ : BilinForm A M₁
B₂ : BilinForm R M₂
hB₁ : IsSymm B₁
hB₂ : IsSymm B₂
⊢ toLin ((flipHom R) (BilinForm.tmul B₁ B₂)) = toLin (BilinForm.tmul B₁ B₂)

Next tactic:
ext x₁ x₂ y₁ y₂
attribute [ext] TensorProduct.ext in
/-- A tensor product of symmetric bilinear forms is symmetric. -/
lemma IsSymm.tmul {B₁ : BilinForm A M₁} {B₂ : BilinForm R M₂}
    (hB₁ : B₁.IsSymm) (hB₂ : B₂.IsSymm) : (B₁.tmul B₂).IsSymm := by
  rw [isSymm_iff_flip R]
  apply toLin.injective
  ext x₁ x₂ y₁ y₂
  

Proof state:
case a.a.h.h.a.h.h
ι : Type uι
R : Type uR
A : Type uA
M₁ : Type uM₁
M₂ : Type uM₂
inst✝¹⁰ : CommSemiring R
inst✝⁹ : CommSemiring A
inst✝⁸ : AddCommMonoid M₁
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : Algebra R A
inst✝⁵ : Module R M₁
inst✝⁴ : Module A M₁
inst✝³ : SMulCommClass R A M₁
inst✝² : SMulCommClass A R M₁
inst✝¹ : IsScalarTower R A M₁
inst✝ : Module R M₂
B₁ : BilinForm A M₁
B₂ : BilinForm R M₂
hB₁ : IsSymm B₁
hB₂ : IsSymm B₂
x₁ : M₁
x₂ : M₂
y₁ : M₁
y₂ : M₂
⊢ ((AlgebraTensorModule.curry (((AlgebraTensorModule.curry (toLin ((flipHom R) (BilinForm.tmul B₁ B₂)))) x₁) x₂)) y₁)
      y₂ =
    ((AlgebraTensorModule.curry (((AlgebraTensorModule.curry (toLin (BilinForm.tmul B₁ B₂))) x₁) x₂)) y₁) y₂

Next tactic:
exact (congr_arg₂ (HSMul.hSMul) (hB₂ x₂ y₂) (hB₁ x₁ y₁)).symm
variable (R M₁ M₂) in
-- TODO: make this `rfl`
@[simp]
theorem tensorDistribEquiv_toLinearMap :
    (tensorDistribEquiv R (M₁ := M₁) (M₂ := M₂)).toLinearMap = tensorDistrib R R := by
  

Proof state:
ι : Type uι
R : Type uR
A : Type uA
M₁ : Type uM₁
M₂ : Type uM₂
inst✝⁹ : CommRing R
inst✝⁸ : AddCommGroup M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₁
inst✝⁵ : Module R M₂
inst✝⁴ : Module.Free R M₁
inst✝³ : Module.Finite R M₁
inst✝² : Module.Free R M₂
inst✝¹ : Module.Finite R M₂
inst✝ : Nontrivial R
⊢ ↑(tensorDistribEquiv R) = tensorDistrib R R

Next tactic:
ext B₁ B₂ : 3
variable (R M₁ M₂) in
-- TODO: make this `rfl`
@[simp]
theorem tensorDistribEquiv_toLinearMap :
    (tensorDistribEquiv R (M₁ := M₁) (M₂ := M₂)).toLinearMap = tensorDistrib R R := by
  ext B₁ B₂ : 3
  

Proof state:
case a.h.h
ι : Type uι
R : Type uR
A : Type uA
M₁ : Type uM₁
M₂ : Type uM₂
inst✝⁹ : CommRing R
inst✝⁸ : AddCommGroup M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₁
inst✝⁵ : Module R M₂
inst✝⁴ : Module.Free R M₁
inst✝³ : Module.Finite R M₁
inst✝² : Module.Free R M₂
inst✝¹ : Module.Finite R M₂
inst✝ : Nontrivial R
B₁ : BilinForm R M₁
B₂ : BilinForm R M₂
⊢ ((AlgebraTensorModule.curry ↑(tensorDistribEquiv R)) B₁) B₂ = ((AlgebraTensorModule.curry (tensorDistrib R R)) B₁) B₂

Next tactic:
apply toLin.injective
variable (R M₁ M₂) in
-- TODO: make this `rfl`
@[simp]
theorem tensorDistribEquiv_toLinearMap :
    (tensorDistribEquiv R (M₁ := M₁) (M₂ := M₂)).toLinearMap = tensorDistrib R R := by
  ext B₁ B₂ : 3
  apply toLin.injective
  

Proof state:
case a.h.h.a
ι : Type uι
R : Type uR
A : Type uA
M₁ : Type uM₁
M₂ : Type uM₂
inst✝⁹ : CommRing R
inst✝⁸ : AddCommGroup M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₁
inst✝⁵ : Module R M₂
inst✝⁴ : Module.Free R M₁
inst✝³ : Module.Finite R M₁
inst✝² : Module.Free R M₂
inst✝¹ : Module.Finite R M₂
inst✝ : Nontrivial R
B₁ : BilinForm R M₁
B₂ : BilinForm R M₂
⊢ toLin (((AlgebraTensorModule.curry ↑(tensorDistribEquiv R)) B₁) B₂) =
    toLin (((AlgebraTensorModule.curry (tensorDistrib R R)) B₁) B₂)

Next tactic:
ext