File: Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean

full_name: galLift
code: /-- The lift `End(B/A) → End(L/K)` in an ALKB setup.
This is inverse to the restriction. See `galRestrictHom`. -/
noncomputable
def galLift (σ : B →ₐ[A] B) : L →ₐ[K] L 
goal: L →ₐ[K] L

full_name: galRestrictHom
code: /-- The restriction `End(L/K) → End(B/A)` in an AKLB setup.
Also see `galRestrict` for the `AlgEquiv` version. -/
noncomputable
def galRestrictHom : (L →ₐ[K] L) ≃* (B →ₐ[A] B) 
goal: (L →ₐ[K] L) ≃* (B →ₐ[A] B)

full_name: algebraMap_galRestrictHom_apply
code: @[simp]
lemma algebraMap_galRestrictHom_apply (σ : L →ₐ[K] L) (x : B) :
    algebraMap B L (galRestrictHom A K L B σ x) = σ (algebraMap B L x) 
goal: (algebraMap B L) (((galRestrictHom A K L B) σ) x) = σ ((algebraMap B L) x)

full_name: galRestrictHom_symm_algebraMap_apply
code: @[simp, nolint unusedHavesSuffices] -- false positive from unfolding galRestrictHom
lemma galRestrictHom_symm_algebraMap_apply (σ : B →ₐ[A] B) (x : B) :
    (galRestrictHom A K L B).symm σ (algebraMap B L x) = algebraMap B L (σ x) 
goal: ((galRestrictHom A K L B).symm σ) ((algebraMap B L) x) = (algebraMap B L) (σ x)

full_name: galRestrict
code: /-- The restriction `Aut(L/K) → Aut(B/A)` in an AKLB setup. -/
noncomputable
def galRestrict : (L ≃ₐ[K] L) ≃* (B ≃ₐ[A] B) 
goal: (L ≃ₐ[K] L) ≃* B ≃ₐ[A] B

full_name: coe_galRestrict_apply
code: lemma coe_galRestrict_apply (σ : L ≃ₐ[K] L) :
    (galRestrict A K L B σ : B →ₐ[A] B) = galRestrictHom A K L B σ 
goal: ↑((galRestrict A K L B) σ) = (galRestrictHom A K L B) ↑σ

full_name: galRestrict_apply
code: lemma galRestrict_apply (σ : L ≃ₐ[K] L) (x : B) :
    galRestrict A K L B σ x = galRestrictHom A K L B σ x 
goal: ((galRestrict A K L B) σ) x = ((galRestrictHom A K L B) ↑σ) x

full_name: algebraMap_galRestrict_apply
code: lemma algebraMap_galRestrict_apply (σ : L ≃ₐ[K] L) (x : B) :
    algebraMap B L (galRestrict A K L B σ x) = σ (algebraMap B L x) 
goal: (algebraMap B L) (((galRestrict A K L B) σ) x) = σ ((algebraMap B L) x)

full_name: prod_galRestrict_eq_norm
code: lemma prod_galRestrict_eq_norm [IsGalois K L] [IsIntegrallyClosed A] (x : B) :
    (∏ σ : L ≃ₐ[K] L, galRestrict A K L B σ x) =
    algebraMap A B (IsIntegralClosure.mk' (R := A) A (Algebra.norm K <| algebraMap B L x)
      (Algebra.isIntegral_norm K (IsIntegralClosure.isIntegral A L x).algebraMap)) 
goal: ∏ σ : L ≃ₐ[K] L, ((galRestrict A K L B) σ) x =
  (algebraMap A B) (IsIntegralClosure.mk' A ((Algebra.norm K) ((algebraMap B L) x)) ⋯)

full_name: instFintypeAlgEquivOfIsDomainOfIsIntegrallyClosedOfFiniteOfNoZeroSMulDivisors
code: noncomputable
instance (priority := 900) [IsDomain A] [IsDomain B] [IsIntegrallyClosed B]
    [Module.Finite A B] [NoZeroSMulDivisors A B] : Fintype (B ≃ₐ[A] B) 
goal: Fintype (B ≃ₐ[A] B)

full_name: Algebra.intTraceAux
code: /-- The restriction of the trace on `L/K` restricted onto `B/A` in an AKLB setup.
See `Algebra.intTrace` instead. -/
noncomputable
def Algebra.intTraceAux [IsIntegrallyClosed A] :
    B →ₗ[A] A 
goal: B →ₗ[A] A

full_name: Algebra.map_intTraceAux
code: lemma Algebra.map_intTraceAux [IsIntegrallyClosed A] (x : B) :
    algebraMap A K (Algebra.intTraceAux A K L B x) = Algebra.trace K L (algebraMap B L x) 
goal: (algebraMap A K) ((Algebra.intTraceAux A K L B) x) = (Algebra.trace K L) ((algebraMap B L) x)

full_name: Algebra.intTrace
code: /-- The trace of a finite extension of integrally closed domains `B/A` is the restriction of
the trace on `Frac(B)/Frac(A)` onto `B/A`. See `Algebra.algebraMap_intTrace`. -/
noncomputable
def Algebra.intTrace : B →ₗ[A] A 
goal: B →ₗ[A] A

full_name: Algebra.algebraMap_intTrace
code: lemma Algebra.algebraMap_intTrace (x : B) :
    algebraMap A K (Algebra.intTrace A B x) = Algebra.trace K L (algebraMap B L x) 
goal: (algebraMap A K) ((Algebra.intTrace A B) x) = (Algebra.trace K L) ((algebraMap B L) x)

full_name: Algebra.algebraMap_intTrace_fractionRing
code: lemma Algebra.algebraMap_intTrace_fractionRing (x : B) :
    algebraMap A (FractionRing A) (Algebra.intTrace A B x) =
      Algebra.trace (FractionRing A) (FractionRing B) (algebraMap B _ x) 
goal: (algebraMap A (FractionRing A)) ((Algebra.intTrace A B) x) =
  (Algebra.trace (FractionRing A) (FractionRing B)) ((algebraMap B (FractionRing B)) x)

full_name: Algebra.intTrace_eq_trace
code: lemma Algebra.intTrace_eq_trace [Module.Free A B] : Algebra.intTrace A B = Algebra.trace A B 
goal: Algebra.intTrace A B = Algebra.trace A B

full_name: Algebra.intTrace_eq_of_isLocalization
code: lemma Algebra.intTrace_eq_of_isLocalization
    (x : B) :
    algebraMap A Aₘ (Algebra.intTrace A B x) = Algebra.intTrace Aₘ Bₘ (algebraMap B Bₘ x) 
goal: (algebraMap A Aₘ) ((Algebra.intTrace A B) x) = (Algebra.intTrace Aₘ Bₘ) ((algebraMap B Bₘ) x)

full_name: Algebra.intNormAux
code: /-- The restriction of the norm on `L/K` restricted onto `B/A` in an AKLB setup.
See `Algebra.intNorm` instead. -/
noncomputable
def Algebra.intNormAux [Algebra.IsSeparable K L] :
    B →* A 
goal: B →* A

full_name: Algebra.map_intNormAux
code: lemma Algebra.map_intNormAux [IsIntegrallyClosed A] [Algebra.IsSeparable K L] (x : B) :
    algebraMap A K (Algebra.intNormAux A K L B x) = Algebra.norm K (algebraMap B L x) 
goal: (algebraMap A K) ((Algebra.intNormAux A K L B) x) = (Algebra.norm K) ((algebraMap B L) x)

full_name: Algebra.intNorm
code: /-- The norm of a finite extension of integrally closed domains `B/A` is the restriction of
the norm on `Frac(B)/Frac(A)` onto `B/A`. See `Algebra.algebraMap_intNorm`. -/
noncomputable
def Algebra.intNorm : B →* A 
goal: B →* A

full_name: Algebra.algebraMap_intNorm
code: lemma Algebra.algebraMap_intNorm (x : B) :
    algebraMap A K (Algebra.intNorm A B x) = Algebra.norm K (algebraMap B L x) 
goal: (algebraMap A K) ((Algebra.intNorm A B) x) = (Algebra.norm K) ((algebraMap B L) x)

full_name: Algebra.algebraMap_intNorm_fractionRing
code: @[simp]
lemma Algebra.algebraMap_intNorm_fractionRing (x : B) :
    algebraMap A (FractionRing A) (Algebra.intNorm A B x) =
      Algebra.norm (FractionRing A) (algebraMap B (FractionRing B) x) 
goal: (algebraMap A (FractionRing A)) ((Algebra.intNorm A B) x) =
  (Algebra.norm (FractionRing A)) ((algebraMap B (FractionRing B)) x)

full_name: Algebra.intNorm_eq_norm
code: lemma Algebra.intNorm_eq_norm [Module.Free A B] : Algebra.intNorm A B = Algebra.norm A 
goal: Algebra.intNorm A B = Algebra.norm A

full_name: Algebra.intNorm_zero
code: @[simp]
lemma Algebra.intNorm_zero : Algebra.intNorm A B 0 = 0 
goal: (Algebra.intNorm A B) 0 = 0

full_name: Algebra.intNorm_eq_zero
code: @[simp]
lemma Algebra.intNorm_eq_zero {x : B} : Algebra.intNorm A B x = 0 ↔ x = 0 
goal: (Algebra.intNorm A B) x = 0 ↔ x = 0

full_name: Algebra.intNorm_ne_zero
code: lemma Algebra.intNorm_ne_zero {x : B} : Algebra.intNorm A B x ≠ 0 ↔ x ≠ 0 
goal: (Algebra.intNorm A B) x ≠ 0 ↔ x ≠ 0

full_name: Algebra.intNorm_eq_of_isLocalization
code: lemma Algebra.intNorm_eq_of_isLocalization (x : B) :
    algebraMap A Aₘ (Algebra.intNorm A B x) = Algebra.intNorm Aₘ Bₘ (algebraMap B Bₘ x) 
goal: (algebraMap A Aₘ) ((Algebra.intNorm A B) x) = (Algebra.intNorm Aₘ Bₘ) ((algebraMap B Bₘ) x)

full_name: Algebra.algebraMap_intNorm_of_isGalois
code: lemma Algebra.algebraMap_intNorm_of_isGalois
    [IsDomain A] [IsIntegrallyClosed A] [IsDomain B] [IsIntegrallyClosed B]
    [Module.Finite A B] [NoZeroSMulDivisors A B] [IsGalois (FractionRing A) (FractionRing B)]
    {x : B} :
    algebraMap A B (Algebra.intNorm A B x) = ∏ σ : B ≃ₐ[A] B, σ x 
goal: (algebraMap A B) ((Algebra.intNorm A B) x) = ∏ σ : B ≃ₐ[A] B, σ x