l3lab/ntp-mathlib huggingface dataset:
/-- Transfer `MulAction` across an `Equiv` -/
@[reducible]
protected def mulAction (e : α ≃ β) [MulAction R β] : MulAction R α :=
  { e.smul R with
    one_smul := by 

Proof state:
α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝¹ : Monoid R
e : α ≃ β
inst✝ : MulAction R β
src✝ : SMul R α := Equiv.smul e R
⊢ ∀ (b : α), 1 • b = b

Next tactic:
simp [smul_def]
/-- Transfer `MulAction` across an `Equiv` -/
@[reducible]
protected def mulAction (e : α ≃ β) [MulAction R β] : MulAction R α :=
  { e.smul R with
    one_smul := by simp [smul_def]
    mul_smul := by 

Proof state:
α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝¹ : Monoid R
e : α ≃ β
inst✝ : MulAction R β
src✝ : SMul R α := Equiv.smul e R
⊢ ∀ (x y : R) (b : α), (x * y) • b = x • y • b

Next tactic:
simp [smul_def, mul_smul]
/-- Transfer `DistribMulAction` across an `Equiv` -/
@[reducible]
protected def distribMulAction (e : α ≃ β) [AddCommMonoid β] :
    letI := Equiv.addCommMonoid e
    ∀ [DistribMulAction R β], DistribMulAction R α := by
  

Proof state:
α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝¹ : Monoid R
e : α ≃ β
inst✝ : AddCommMonoid β
⊢ [inst : DistribMulAction R β] → DistribMulAction R α

Next tactic:
intros
/-- Transfer `DistribMulAction` across an `Equiv` -/
@[reducible]
protected def distribMulAction (e : α ≃ β) [AddCommMonoid β] :
    letI := Equiv.addCommMonoid e
    ∀ [DistribMulAction R β], DistribMulAction R α := by
  intros
  

Proof state:
α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝² : Monoid R
e : α ≃ β
inst✝¹ : AddCommMonoid β
inst✝ : DistribMulAction R β
⊢ DistribMulAction R α

Next tactic:
letI := Equiv.addCommMonoid e
/-- Transfer `DistribMulAction` across an `Equiv` -/
@[reducible]
protected def distribMulAction (e : α ≃ β) [AddCommMonoid β] :
    letI := Equiv.addCommMonoid e
    ∀ [DistribMulAction R β], DistribMulAction R α := by
  intros
  letI := Equiv.addCommMonoid e
  

Proof state:
α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝² : Monoid R
e : α ≃ β
inst✝¹ : AddCommMonoid β
inst✝ : DistribMulAction R β
this : AddCommMonoid α := Equiv.addCommMonoid e
⊢ DistribMulAction R α

Next tactic:
exact
    ({ Equiv.mulAction R e with
        smul_zero := by simp [zero_def, smul_def]
        smul_add := by simp [add_def, smul_def, smul_add] } :
      DistribMulAction R α)
/-- Transfer `DistribMulAction` across an `Equiv` -/
@[reducible]
protected def distribMulAction (e : α ≃ β) [AddCommMonoid β] :
    letI := Equiv.addCommMonoid e
    ∀ [DistribMulAction R β], DistribMulAction R α := by
  intros
  letI := Equiv.addCommMonoid e
  exact
    ({ Equiv.mulAction R e with
        smul_zero := by 

Proof state:
α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝² : Monoid R
e : α ≃ β
inst✝¹ : AddCommMonoid β
inst✝ : DistribMulAction R β
this : AddCommMonoid α := Equiv.addCommMonoid e
src✝ : MulAction R α := Equiv.mulAction R e
⊢ ∀ (a : R), a • 0 = 0

Next tactic:
simp [zero_def, smul_def]
/-- Transfer `DistribMulAction` across an `Equiv` -/
@[reducible]
protected def distribMulAction (e : α ≃ β) [AddCommMonoid β] :
    letI := Equiv.addCommMonoid e
    ∀ [DistribMulAction R β], DistribMulAction R α := by
  intros
  letI := Equiv.addCommMonoid e
  exact
    ({ Equiv.mulAction R e with
        smul_zero := by simp [zero_def, smul_def]
        smul_add := by 

Proof state:
α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝² : Monoid R
e : α ≃ β
inst✝¹ : AddCommMonoid β
inst✝ : DistribMulAction R β
this : AddCommMonoid α := Equiv.addCommMonoid e
src✝ : MulAction R α := Equiv.mulAction R e
⊢ ∀ (a : R) (x y : α), a • (x + y) = a • x + a • y

Next tactic:
simp [add_def, smul_def, smul_add]
/-- Transfer `Module` across an `Equiv` -/
@[reducible]
protected def module (e : α ≃ β) [AddCommMonoid β] :
    let addCommMonoid := Equiv.addCommMonoid e
    ∀ [Module R β], Module R α := by
  

Proof state:
α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝¹ : Semiring R
e : α ≃ β
inst✝ : AddCommMonoid β
⊢ let addCommMonoid := Equiv.addCommMonoid e;
  [inst : Module R β] → Module R α

Next tactic:
intros
/-- Transfer `Module` across an `Equiv` -/
@[reducible]
protected def module (e : α ≃ β) [AddCommMonoid β] :
    let addCommMonoid := Equiv.addCommMonoid e
    ∀ [Module R β], Module R α := by
  intros
  

Proof state:
α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝² : Semiring R
e : α ≃ β
inst✝¹ : AddCommMonoid β
addCommMonoid✝ : AddCommMonoid α := Equiv.addCommMonoid e
inst✝ : Module R β
⊢ Module R α

Next tactic:
exact
    ({ Equiv.distribMulAction R e with
        zero_smul := by simp [smul_def, zero_smul, zero_def]
        add_smul := by simp [add_def, smul_def, add_smul] } :
      Module R α)
/-- Transfer `Module` across an `Equiv` -/
@[reducible]
protected def module (e : α ≃ β) [AddCommMonoid β] :
    let addCommMonoid := Equiv.addCommMonoid e
    ∀ [Module R β], Module R α := by
  intros
  exact
    ({ Equiv.distribMulAction R e with
        zero_smul := by simp [smul_def, zero_smul, zero_def]
        add_smul := by 

Proof state:
α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝² : Semiring R
e : α ≃ β
inst✝¹ : AddCommMonoid β
addCommMonoid✝ : AddCommMonoid α := Equiv.addCommMonoid e
inst✝ : Module R β
src✝ : DistribMulAction R α := Equiv.distribMulAction R e
⊢ ∀ (r s : R) (x : α), (r + s) • x = r • x + s • x

Next tactic:
simp [add_def, smul_def, add_smul]
/-- Transfer `Module` across an `Equiv` -/
@[reducible]
protected def module (e : α ≃ β) [AddCommMonoid β] :
    let addCommMonoid := Equiv.addCommMonoid e
    ∀ [Module R β], Module R α := by
  intros
  exact
    ({ Equiv.distribMulAction R e with
        zero_smul := by 

Proof state:
α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝² : Semiring R
e : α ≃ β
inst✝¹ : AddCommMonoid β
addCommMonoid✝ : AddCommMonoid α := Equiv.addCommMonoid e
inst✝ : Module R β
src✝ : DistribMulAction R α := Equiv.distribMulAction R e
⊢ ∀ (x : α), 0 • x = 0

Next tactic:
simp [smul_def, zero_smul, zero_def]
/-- An equivalence `e : α ≃ β` gives a linear equivalence `α ≃ₗ[R] β`
where the `R`-module structure on `α` is
the one obtained by transporting an `R`-module structure on `β` back along `e`.
-/
def linearEquiv (e : α ≃ β) [AddCommMonoid β] [Module R β] : by
    

Proof state:
α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝² : Semiring R
e : α ≃ β
inst✝¹ : AddCommMonoid β
inst✝ : Module R β
⊢ Sort ?u.354422

Next tactic:
let addCommMonoid := Equiv.addCommMonoid e
/-- An equivalence `e : α ≃ β` gives a linear equivalence `α ≃ₗ[R] β`
where the `R`-module structure on `α` is
the one obtained by transporting an `R`-module structure on `β` back along `e`.
-/
def linearEquiv (e : α ≃ β) [AddCommMonoid β] [Module R β] : by
    let addCommMonoid := Equiv.addCommMonoid e
    

Proof state:
α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝² : Semiring R
e : α ≃ β
inst✝¹ : AddCommMonoid β
inst✝ : Module R β
addCommMonoid : AddCommMonoid α := Equiv.addCommMonoid e
⊢ Sort ?u.354422

Next tactic:
let module := Equiv.module R e
/-- An equivalence `e : α ≃ β` gives a linear equivalence `α ≃ₗ[R] β`
where the `R`-module structure on `α` is
the one obtained by transporting an `R`-module structure on `β` back along `e`.
-/
def linearEquiv (e : α ≃ β) [AddCommMonoid β] [Module R β] : by
    let addCommMonoid := Equiv.addCommMonoid e
    let module := Equiv.module R e
    

Proof state:
α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝² : Semiring R
e : α ≃ β
inst✝¹ : AddCommMonoid β
inst✝ : Module R β
addCommMonoid : AddCommMonoid α := Equiv.addCommMonoid e
module : Module R α := Equiv.module R e
⊢ Sort ?u.354422

Next tactic:
exact α ≃ₗ[R] β
/-- An equivalence `e : α ≃ β` gives a linear equivalence `α ≃ₗ[R] β`
where the `R`-module structure on `α` is
the one obtained by transporting an `R`-module structure on `β` back along `e`.
-/
def linearEquiv (e : α ≃ β) [AddCommMonoid β] [Module R β] : by
    let addCommMonoid := Equiv.addCommMonoid e
    let module := Equiv.module R e
    exact α ≃ₗ[R] β := by
  

Proof state:
α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝² : Semiring R
e : α ≃ β
inst✝¹ : AddCommMonoid β
inst✝ : Module R β
⊢ let addCommMonoid := Equiv.addCommMonoid e;
  let module := Equiv.module R e;
  α ≃ₗ[R] β

Next tactic:
intros
/-- An equivalence `e : α ≃ β` gives a linear equivalence `α ≃ₗ[R] β`
where the `R`-module structure on `α` is
the one obtained by transporting an `R`-module structure on `β` back along `e`.
-/
def linearEquiv (e : α ≃ β) [AddCommMonoid β] [Module R β] : by
    let addCommMonoid := Equiv.addCommMonoid e
    let module := Equiv.module R e
    exact α ≃ₗ[R] β := by
  intros
  

Proof state:
α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝² : Semiring R
e : α ≃ β
inst✝¹ : AddCommMonoid β
inst✝ : Module R β
addCommMonoid✝ : AddCommMonoid α := Equiv.addCommMonoid e
module✝ : Module R α := Equiv.module R e
⊢ α ≃ₗ[R] β

Next tactic:
exact
    { Equiv.addEquiv e with
      map_smul' := fun r x => by
        apply e.symm.injective
        simp only [toFun_as_coe, RingHom.id_apply, EmbeddingLike.apply_eq_iff_eq]
        exact Iff.mpr (apply_eq_iff_eq_symm_apply _) rfl }
/-- An equivalence `e : α ≃ β` gives a linear equivalence `α ≃ₗ[R] β`
where the `R`-module structure on `α` is
the one obtained by transporting an `R`-module structure on `β` back along `e`.
-/
def linearEquiv (e : α ≃ β) [AddCommMonoid β] [Module R β] : by
    let addCommMonoid := Equiv.addCommMonoid e
    let module := Equiv.module R e
    exact α ≃ₗ[R] β := by
  intros
  exact
    { Equiv.addEquiv e with
      map_smul' := fun r x => by
        

Proof state:
α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝² : Semiring R
e : α ≃ β
inst✝¹ : AddCommMonoid β
inst✝ : Module R β
addCommMonoid✝ : AddCommMonoid α := Equiv.addCommMonoid e
module✝ : Module R α := Equiv.module R e
src✝ : let mul := Equiv.add e;
α ≃+ β :=
  addEquiv e
r : R
x : α
⊢ AddHom.toFun
      { toFun := src✝.toFun,
        map_add' :=
          (_ :
            ∀ (x y : α), Equiv.toFun src✝.toEquiv (x + y) = Equiv.toFun src✝.toEquiv x + Equiv.toFun src✝.toEquiv y) }
      (r • x) =
    (RingHom.id R) r •
      AddHom.toFun
        { toFun := src✝.toFun,
          map_add' :=
            (_ :
              ∀ (x y : α), Equiv.toFun src✝.toEquiv (x + y) = Equiv.toFun src✝.toEquiv x + Equiv.toFun src✝.toEquiv y) }
        x

Next tactic:
apply e.symm.injective
/-- An equivalence `e : α ≃ β` gives a linear equivalence `α ≃ₗ[R] β`
where the `R`-module structure on `α` is
the one obtained by transporting an `R`-module structure on `β` back along `e`.
-/
def linearEquiv (e : α ≃ β) [AddCommMonoid β] [Module R β] : by
    let addCommMonoid := Equiv.addCommMonoid e
    let module := Equiv.module R e
    exact α ≃ₗ[R] β := by
  intros
  exact
    { Equiv.addEquiv e with
      map_smul' := fun r x => by
        apply e.symm.injective
        

Proof state:
case a
α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝² : Semiring R
e : α ≃ β
inst✝¹ : AddCommMonoid β
inst✝ : Module R β
addCommMonoid✝ : AddCommMonoid α := Equiv.addCommMonoid e
module✝ : Module R α := Equiv.module R e
src✝ : let mul := Equiv.add e;
α ≃+ β :=
  addEquiv e
r : R
x : α
⊢ e.symm
      (AddHom.toFun
        { toFun := src✝.toFun,
          map_add' :=
            (_ :
              ∀ (x y : α), Equiv.toFun src✝.toEquiv (x + y) = Equiv.toFun src✝.toEquiv x + Equiv.toFun src✝.toEquiv y) }
        (r • x)) =
    e.symm
      ((RingHom.id R) r •
        AddHom.toFun
          { toFun := src✝.toFun,
            map_add' :=
              (_ :
                ∀ (x y : α),
                  Equiv.toFun src✝.toEquiv (x + y) = Equiv.toFun src✝.toEquiv x + Equiv.toFun src✝.toEquiv y) }
          x)

Next tactic:
simp only [toFun_as_coe, RingHom.id_apply, EmbeddingLike.apply_eq_iff_eq]
/-- An equivalence `e : α ≃ β` gives a linear equivalence `α ≃ₗ[R] β`
where the `R`-module structure on `α` is
the one obtained by transporting an `R`-module structure on `β` back along `e`.
-/
def linearEquiv (e : α ≃ β) [AddCommMonoid β] [Module R β] : by
    let addCommMonoid := Equiv.addCommMonoid e
    let module := Equiv.module R e
    exact α ≃ₗ[R] β := by
  intros
  exact
    { Equiv.addEquiv e with
      map_smul' := fun r x => by
        apply e.symm.injective
        simp only [toFun_as_coe, RingHom.id_apply, EmbeddingLike.apply_eq_iff_eq]
        

Proof state:
case a
α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝² : Semiring R
e : α ≃ β
inst✝¹ : AddCommMonoid β
inst✝ : Module R β
addCommMonoid✝ : AddCommMonoid α := Equiv.addCommMonoid e
module✝ : Module R α := Equiv.module R e
src✝ : let mul := Equiv.add e;
α ≃+ β :=
  addEquiv e
r : R
x : α
⊢ (addEquiv e).toEquiv (r • x) = r • (addEquiv e).toEquiv x

Next tactic:
exact Iff.mpr (apply_eq_iff_eq_symm_apply _) rfl
/-- Transfer `Algebra` across an `Equiv` -/
@[reducible]
protected def algebra (e : α ≃ β) [Semiring β] :
    let semiring := Equiv.semiring e
    ∀ [Algebra R β], Algebra R α := by
  

Proof state:
α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝¹ : CommSemiring R
e : α ≃ β
inst✝ : Semiring β
⊢ let semiring := Equiv.semiring e;
  [inst : Algebra R β] → Algebra R α

Next tactic:
intros
/-- Transfer `Algebra` across an `Equiv` -/
@[reducible]
protected def algebra (e : α ≃ β) [Semiring β] :
    let semiring := Equiv.semiring e
    ∀ [Algebra R β], Algebra R α := by
  intros
  

Proof state:
α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝² : CommSemiring R
e : α ≃ β
inst✝¹ : Semiring β
semiring✝ : Semiring α := Equiv.semiring e
inst✝ : Algebra R β
⊢ Algebra R α

Next tactic:
fapply RingHom.toAlgebra'
/-- Transfer `Algebra` across an `Equiv` -/
@[reducible]
protected def algebra (e : α ≃ β) [Semiring β] :
    let semiring := Equiv.semiring e
    ∀ [Algebra R β], Algebra R α := by
  intros
  fapply RingHom.toAlgebra'
  · 

Proof state:
case i
α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝² : CommSemiring R
e : α ≃ β
inst✝¹ : Semiring β
semiring✝ : Semiring α := Equiv.semiring e
inst✝ : Algebra R β
⊢ R →+* α

Next tactic:
exact ((ringEquiv e).symm : β →+* α).comp (algebraMap R β)
/-- Transfer `Algebra` across an `Equiv` -/
@[reducible]
protected def algebra (e : α ≃ β) [Semiring β] :
    let semiring := Equiv.semiring e
    ∀ [Algebra R β], Algebra R α := by
  intros
  fapply RingHom.toAlgebra'
  · exact ((ringEquiv e).symm : β →+* α).comp (algebraMap R β)
  · 

Proof state:
case h
α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝² : CommSemiring R
e : α ≃ β
inst✝¹ : Semiring β
semiring✝ : Semiring α := Equiv.semiring e
inst✝ : Algebra R β
⊢ ∀ (c : R) (x : α),
    (RingHom.comp (↑(RingEquiv.symm (ringEquiv e))) (algebraMap R β)) c * x =
      x * (RingHom.comp (↑(RingEquiv.symm (ringEquiv e))) (algebraMap R β)) c

Next tactic:
intro r x
/-- Transfer `Algebra` across an `Equiv` -/
@[reducible]
protected def algebra (e : α ≃ β) [Semiring β] :
    let semiring := Equiv.semiring e
    ∀ [Algebra R β], Algebra R α := by
  intros
  fapply RingHom.toAlgebra'
  · exact ((ringEquiv e).symm : β →+* α).comp (algebraMap R β)
  · intro r x
    

Proof state:
case h
α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝² : CommSemiring R
e : α ≃ β
inst✝¹ : Semiring β
semiring✝ : Semiring α := Equiv.semiring e
inst✝ : Algebra R β
r : R
x : α
⊢ (RingHom.comp (↑(RingEquiv.symm (ringEquiv e))) (algebraMap R β)) r * x =
    x * (RingHom.comp (↑(RingEquiv.symm (ringEquiv e))) (algebraMap R β)) r

Next tactic:
rw [RingHom.coe_comp, Function.comp_apply, RingHom.coe_coe, ringEquiv_symm_apply e]
/-- Transfer `Algebra` across an `Equiv` -/
@[reducible]
protected def algebra (e : α ≃ β) [Semiring β] :
    let semiring := Equiv.semiring e
    ∀ [Algebra R β], Algebra R α := by
  intros
  fapply RingHom.toAlgebra'
  · exact ((ringEquiv e).symm : β →+* α).comp (algebraMap R β)
  · intro r x
    rw [RingHom.coe_comp, Function.comp_apply, RingHom.coe_coe, ringEquiv_symm_apply e]
    

Proof state:
case h
α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝² : CommSemiring R
e : α ≃ β
inst✝¹ : Semiring β
semiring✝ : Semiring α := Equiv.semiring e
inst✝ : Algebra R β
r : R
x : α
⊢ e.symm ((algebraMap R β) r) * x = x * e.symm ((algebraMap R β) r)

Next tactic:
apply (ringEquiv e).injective
/-- Transfer `Algebra` across an `Equiv` -/
@[reducible]
protected def algebra (e : α ≃ β) [Semiring β] :
    let semiring := Equiv.semiring e
    ∀ [Algebra R β], Algebra R α := by
  intros
  fapply RingHom.toAlgebra'
  · exact ((ringEquiv e).symm : β →+* α).comp (algebraMap R β)
  · intro r x
    rw [RingHom.coe_comp, Function.comp_apply, RingHom.coe_coe, ringEquiv_symm_apply e]
    apply (ringEquiv e).injective
    

Proof state:
case h.a
α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝² : CommSemiring R
e : α ≃ β
inst✝¹ : Semiring β
semiring✝ : Semiring α := Equiv.semiring e
inst✝ : Algebra R β
r : R
x : α
⊢ (ringEquiv e) (e.symm ((algebraMap R β) r) * x) = (ringEquiv e) (x * e.symm ((algebraMap R β) r))

Next tactic:
simp [Algebra.commutes]
/-- An equivalence `e : α ≃ β` gives an algebra equivalence `α ≃ₐ[R] β`
where the `R`-algebra structure on `α` is
the one obtained by transporting an `R`-algebra structure on `β` back along `e`.
-/
def algEquiv (e : α ≃ β) [Semiring β] [Algebra R β] : by
    

Proof state:
α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝² : CommSemiring R
e : α ≃ β
inst✝¹ : Semiring β
inst✝ : Algebra R β
⊢ Sort ?u.361964

Next tactic:
let semiring := Equiv.semiring e
/-- An equivalence `e : α ≃ β` gives an algebra equivalence `α ≃ₐ[R] β`
where the `R`-algebra structure on `α` is
the one obtained by transporting an `R`-algebra structure on `β` back along `e`.
-/
def algEquiv (e : α ≃ β) [Semiring β] [Algebra R β] : by
    let semiring := Equiv.semiring e
    

Proof state:
α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝² : CommSemiring R
e : α ≃ β
inst✝¹ : Semiring β
inst✝ : Algebra R β
semiring : Semiring α := Equiv.semiring e
⊢ Sort ?u.361964

Next tactic:
let algebra := Equiv.algebra R e
/-- An equivalence `e : α ≃ β` gives an algebra equivalence `α ≃ₐ[R] β`
where the `R`-algebra structure on `α` is
the one obtained by transporting an `R`-algebra structure on `β` back along `e`.
-/
def algEquiv (e : α ≃ β) [Semiring β] [Algebra R β] : by
    let semiring := Equiv.semiring e
    let algebra := Equiv.algebra R e
    

Proof state:
α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝² : CommSemiring R
e : α ≃ β
inst✝¹ : Semiring β
inst✝ : Algebra R β
semiring : Semiring α := Equiv.semiring e
algebra : Algebra R α := Equiv.algebra R e
⊢ Sort ?u.361964

Next tactic:
exact α ≃ₐ[R] β
/-- An equivalence `e : α ≃ β` gives an algebra equivalence `α ≃ₐ[R] β`
where the `R`-algebra structure on `α` is
the one obtained by transporting an `R`-algebra structure on `β` back along `e`.
-/
def algEquiv (e : α ≃ β) [Semiring β] [Algebra R β] : by
    let semiring := Equiv.semiring e
    let algebra := Equiv.algebra R e
    exact α ≃ₐ[R] β := by
  

Proof state:
α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝² : CommSemiring R
e : α ≃ β
inst✝¹ : Semiring β
inst✝ : Algebra R β
⊢ let semiring := Equiv.semiring e;
  let algebra := Equiv.algebra R e;
  α ≃ₐ[R] β

Next tactic:
intros
/-- An equivalence `e : α ≃ β` gives an algebra equivalence `α ≃ₐ[R] β`
where the `R`-algebra structure on `α` is
the one obtained by transporting an `R`-algebra structure on `β` back along `e`.
-/
def algEquiv (e : α ≃ β) [Semiring β] [Algebra R β] : by
    let semiring := Equiv.semiring e
    let algebra := Equiv.algebra R e
    exact α ≃ₐ[R] β := by
  intros
  

Proof state:
α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝² : CommSemiring R
e : α ≃ β
inst✝¹ : Semiring β
inst✝ : Algebra R β
semiring✝ : Semiring α := Equiv.semiring e
algebra✝ : Algebra R α := Equiv.algebra R e
⊢ α ≃ₐ[R] β

Next tactic:
exact
    { Equiv.ringEquiv e with
      commutes' := fun r => by
        apply e.symm.injective
        simp
        rfl }
/-- An equivalence `e : α ≃ β` gives an algebra equivalence `α ≃ₐ[R] β`
where the `R`-algebra structure on `α` is
the one obtained by transporting an `R`-algebra structure on `β` back along `e`.
-/
def algEquiv (e : α ≃ β) [Semiring β] [Algebra R β] : by
    let semiring := Equiv.semiring e
    let algebra := Equiv.algebra R e
    exact α ≃ₐ[R] β := by
  intros
  exact
    { Equiv.ringEquiv e with
      commutes' := fun r => by
        

Proof state:
α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝² : CommSemiring R
e : α ≃ β
inst✝¹ : Semiring β
inst✝ : Algebra R β
semiring✝ : Semiring α := Equiv.semiring e
algebra✝ : Algebra R α := Equiv.algebra R e
src✝ : let add := Equiv.add e;
let mul := Equiv.mul e;
α ≃+* β :=
  ringEquiv e
r : R
⊢ Equiv.toFun src✝.toEquiv ((algebraMap R α) r) = (algebraMap R β) r

Next tactic:
apply e.symm.injective
/-- An equivalence `e : α ≃ β` gives an algebra equivalence `α ≃ₐ[R] β`
where the `R`-algebra structure on `α` is
the one obtained by transporting an `R`-algebra structure on `β` back along `e`.
-/
def algEquiv (e : α ≃ β) [Semiring β] [Algebra R β] : by
    let semiring := Equiv.semiring e
    let algebra := Equiv.algebra R e
    exact α ≃ₐ[R] β := by
  intros
  exact
    { Equiv.ringEquiv e with
      commutes' := fun r => by
        apply e.symm.injective
        

Proof state:
case a
α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝² : CommSemiring R
e : α ≃ β
inst✝¹ : Semiring β
inst✝ : Algebra R β
semiring✝ : Semiring α := Equiv.semiring e
algebra✝ : Algebra R α := Equiv.algebra R e
src✝ : let add := Equiv.add e;
let mul := Equiv.mul e;
α ≃+* β :=
  ringEquiv e
r : R
⊢ e.symm (Equiv.toFun src✝.toEquiv ((algebraMap R α) r)) = e.symm ((algebraMap R β) r)

Next tactic:
simp
/-- An equivalence `e : α ≃ β` gives an algebra equivalence `α ≃ₐ[R] β`
where the `R`-algebra structure on `α` is
the one obtained by transporting an `R`-algebra structure on `β` back along `e`.
-/
def algEquiv (e : α ≃ β) [Semiring β] [Algebra R β] : by
    let semiring := Equiv.semiring e
    let algebra := Equiv.algebra R e
    exact α ≃ₐ[R] β := by
  intros
  exact
    { Equiv.ringEquiv e with
      commutes' := fun r => by
        apply e.symm.injective
        simp
        

Proof state:
case a
α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝² : CommSemiring R
e : α ≃ β
inst✝¹ : Semiring β
inst✝ : Algebra R β
semiring✝ : Semiring α := Equiv.semiring e
algebra✝ : Algebra R α := Equiv.algebra R e
src✝ : let add := Equiv.add e;
let mul := Equiv.mul e;
α ≃+* β :=
  ringEquiv e
r : R
⊢ (algebraMap R α) r = e.symm ((algebraMap R β) r)

Next tactic:
rfl
theorem Seminorm.continuous_iSup {ι 𝕜 E : Type*} [NormedField 𝕜]  [AddCommGroup E] [Module 𝕜 E]
    [TopologicalSpace E] [BarrelledSpace 𝕜 E] (p : ι → Seminorm 𝕜 E)
    (hp : ∀ i, Continuous (p i)) (bdd : BddAbove (range p)) :
    Continuous (⨆ i, p i) := by
  

Proof state:
ι : Type u_1
𝕜 : Type u_2
E : Type u_3
inst✝⁴ : NormedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : TopologicalSpace E
inst✝ : BarrelledSpace 𝕜 E
p : ι → Seminorm 𝕜 E
hp : ∀ (i : ι), Continuous ⇑(p i)
bdd : BddAbove (range p)
⊢ Continuous (⨆ i, ⇑(p i))

Next tactic:
rw [← Seminorm.coe_iSup_eq bdd]
theorem Seminorm.continuous_iSup {ι 𝕜 E : Type*} [NormedField 𝕜]  [AddCommGroup E] [Module 𝕜 E]
    [TopologicalSpace E] [BarrelledSpace 𝕜 E] (p : ι → Seminorm 𝕜 E)
    (hp : ∀ i, Continuous (p i)) (bdd : BddAbove (range p)) :
    Continuous (⨆ i, p i) := by
  rw [← Seminorm.coe_iSup_eq bdd]
  

Proof state:
ι : Type u_1
𝕜 : Type u_2
E : Type u_3
inst✝⁴ : NormedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : TopologicalSpace E
inst✝ : BarrelledSpace 𝕜 E
p : ι → Seminorm 𝕜 E
hp : ∀ (i : ι), Continuous ⇑(p i)
bdd : BddAbove (range p)
⊢ Continuous ⇑(⨆ i, p i)

Next tactic:
refine Seminorm.continuous_of_lowerSemicontinuous _ ?_
theorem Seminorm.continuous_iSup {ι 𝕜 E : Type*} [NormedField 𝕜]  [AddCommGroup E] [Module 𝕜 E]
    [TopologicalSpace E] [BarrelledSpace 𝕜 E] (p : ι → Seminorm 𝕜 E)
    (hp : ∀ i, Continuous (p i)) (bdd : BddAbove (range p)) :
    Continuous (⨆ i, p i) := by
  rw [← Seminorm.coe_iSup_eq bdd]
  refine Seminorm.continuous_of_lowerSemicontinuous _ ?_
  

Proof state:
ι : Type u_1
𝕜 : Type u_2
E : Type u_3
inst✝⁴ : NormedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : TopologicalSpace E
inst✝ : BarrelledSpace 𝕜 E
p : ι → Seminorm 𝕜 E
hp : ∀ (i : ι), Continuous ⇑(p i)
bdd : BddAbove (range p)
⊢ LowerSemicontinuous ⇑(⨆ i, p i)

Next tactic:
rw [Seminorm.coe_iSup_eq bdd]