l3lab/ntp-mathlib huggingface dataset:
/--
The `R`-linear equivalence between additive morphisms `A →+ B` and `ℤ`-linear morphisms `A →ₗ[ℤ] B`.
-/
@[simps]
def addMonoidHomLequivInt {A B : Type*} (R : Type*) [Semiring R] [AddCommGroup A] [AddCommGroup B]
    [Module R B] : (A →+ B) ≃ₗ[R] A →ₗ[ℤ] B
    where
  toFun := AddMonoidHom.toIntLinearMap
  invFun := LinearMap.toAddMonoidHom
  map_add' := by intros; ext; rfl
  map_smul' := by intros; ext; 

Proof state:
case h
R✝ : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
R₄ : Type u_5
S : Type u_6
K : Type u_7
K₂ : Type u_8
M : Type u_9
M' : Type u_10
M₁ : Type u_11
M₂ : Type u_12
M₃ : Type u_13
M₄ : Type u_14
N : Type u_15
N₂ : Type u_16
ι : Type u_17
V : Type u_18
V₂ : Type u_19
A : Type u_20
B : Type u_21
R : Type u_22
inst✝³ : Semiring R
inst✝² : AddCommGroup A
inst✝¹ : AddCommGroup B
inst✝ : Module R B
r✝ : R
x✝¹ : A →+ B
x✝ : A
⊢ (AddHom.toFun
        { toFun := AddMonoidHom.toIntLinearMap,
          map_add' :=
            (_ :
              ∀ (x y : A →+ B),
                AddMonoidHom.toIntLinearMap (x + y) = AddMonoidHom.toIntLinearMap x + AddMonoidHom.toIntLinearMap y) }
        (r✝ • x✝¹))
      x✝ =
    ((RingHom.id R) r✝ •
        AddHom.toFun
          { toFun := AddMonoidHom.toIntLinearMap,
            map_add' :=
              (_ :
                ∀ (x y : A →+ B),
                  AddMonoidHom.toIntLinearMap (x + y) = AddMonoidHom.toIntLinearMap x + AddMonoidHom.toIntLinearMap y) }
          x✝¹)
      x✝

Next tactic:
rfl
/--
The `R`-linear equivalence between additive morphisms `A →+ B` and `ℤ`-linear morphisms `A →ₗ[ℤ] B`.
-/
@[simps]
def addMonoidHomLequivInt {A B : Type*} (R : Type*) [Semiring R] [AddCommGroup A] [AddCommGroup B]
    [Module R B] : (A →+ B) ≃ₗ[R] A →ₗ[ℤ] B
    where
  toFun := AddMonoidHom.toIntLinearMap
  invFun := LinearMap.toAddMonoidHom
  map_add' := by intros; ext; rfl
  map_smul' := by intros; ext; rfl
  left_inv := by 

Proof state:
R✝ : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
R₄ : Type u_5
S : Type u_6
K : Type u_7
K₂ : Type u_8
M : Type u_9
M' : Type u_10
M₁ : Type u_11
M₂ : Type u_12
M₃ : Type u_13
M₄ : Type u_14
N : Type u_15
N₂ : Type u_16
ι : Type u_17
V : Type u_18
V₂ : Type u_19
A : Type u_20
B : Type u_21
R : Type u_22
inst✝³ : Semiring R
inst✝² : AddCommGroup A
inst✝¹ : AddCommGroup B
inst✝ : Module R B
⊢ LeftInverse LinearMap.toAddMonoidHom
    {
          toAddHom :=
            { toFun := AddMonoidHom.toIntLinearMap,
              map_add' :=
                (_ :
                  ∀ (x y : A →+ B),
                    AddMonoidHom.toIntLinearMap (x + y) =
                      AddMonoidHom.toIntLinearMap x + AddMonoidHom.toIntLinearMap y) },
          map_smul' :=
            (_ :
              ∀ (r : R) (x : A →+ B),
                AddHom.toFun
                    { toFun := AddMonoidHom.toIntLinearMap,
                      map_add' :=
                        (_ :
                          ∀ (x y : A →+ B),
                            AddMonoidHom.toIntLinearMap (x + y) =
                              AddMonoidHom.toIntLinearMap x + AddMonoidHom.toIntLinearMap y) }
                    (r • x) =
                  (RingHom.id R) r •
                    AddHom.toFun
                      { toFun := AddMonoidHom.toIntLinearMap,
                        map_add' :=
                          (_ :
                            ∀ (x y : A →+ B),
                              AddMonoidHom.toIntLinearMap (x + y) =
                                AddMonoidHom.toIntLinearMap x + AddMonoidHom.toIntLinearMap y) }
                      x) }.toAddHom.toFun

Next tactic:
intro f
/--
The `R`-linear equivalence between additive morphisms `A →+ B` and `ℤ`-linear morphisms `A →ₗ[ℤ] B`.
-/
@[simps]
def addMonoidHomLequivInt {A B : Type*} (R : Type*) [Semiring R] [AddCommGroup A] [AddCommGroup B]
    [Module R B] : (A →+ B) ≃ₗ[R] A →ₗ[ℤ] B
    where
  toFun := AddMonoidHom.toIntLinearMap
  invFun := LinearMap.toAddMonoidHom
  map_add' := by intros; ext; rfl
  map_smul' := by intros; ext; rfl
  left_inv := by intro f; 

Proof state:
R✝ : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
R₄ : Type u_5
S : Type u_6
K : Type u_7
K₂ : Type u_8
M : Type u_9
M' : Type u_10
M₁ : Type u_11
M₂ : Type u_12
M₃ : Type u_13
M₄ : Type u_14
N : Type u_15
N₂ : Type u_16
ι : Type u_17
V : Type u_18
V₂ : Type u_19
A : Type u_20
B : Type u_21
R : Type u_22
inst✝³ : Semiring R
inst✝² : AddCommGroup A
inst✝¹ : AddCommGroup B
inst✝ : Module R B
f : A →+ B
⊢ LinearMap.toAddMonoidHom
      (AddHom.toFun
        {
            toAddHom :=
              { toFun := AddMonoidHom.toIntLinearMap,
                map_add' :=
                  (_ :
                    ∀ (x y : A →+ B),
                      AddMonoidHom.toIntLinearMap (x + y) =
                        AddMonoidHom.toIntLinearMap x + AddMonoidHom.toIntLinearMap y) },
            map_smul' :=
              (_ :
                ∀ (r : R) (x : A →+ B),
                  AddHom.toFun
                      { toFun := AddMonoidHom.toIntLinearMap,
                        map_add' :=
                          (_ :
                            ∀ (x y : A →+ B),
                              AddMonoidHom.toIntLinearMap (x + y) =
                                AddMonoidHom.toIntLinearMap x + AddMonoidHom.toIntLinearMap y) }
                      (r • x) =
                    (RingHom.id R) r •
                      AddHom.toFun
                        { toFun := AddMonoidHom.toIntLinearMap,
                          map_add' :=
                            (_ :
                              ∀ (x y : A →+ B),
                                AddMonoidHom.toIntLinearMap (x + y) =
                                  AddMonoidHom.toIntLinearMap x + AddMonoidHom.toIntLinearMap y) }
                        x) }.toAddHom
        f) =
    f

Next tactic:
ext
/--
The `R`-linear equivalence between additive morphisms `A →+ B` and `ℤ`-linear morphisms `A →ₗ[ℤ] B`.
-/
@[simps]
def addMonoidHomLequivInt {A B : Type*} (R : Type*) [Semiring R] [AddCommGroup A] [AddCommGroup B]
    [Module R B] : (A →+ B) ≃ₗ[R] A →ₗ[ℤ] B
    where
  toFun := AddMonoidHom.toIntLinearMap
  invFun := LinearMap.toAddMonoidHom
  map_add' := by intros; ext; rfl
  map_smul' := by intros; ext; rfl
  left_inv := by intro f; ext; 

Proof state:
case h
R✝ : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
R₄ : Type u_5
S : Type u_6
K : Type u_7
K₂ : Type u_8
M : Type u_9
M' : Type u_10
M₁ : Type u_11
M₂ : Type u_12
M₃ : Type u_13
M₄ : Type u_14
N : Type u_15
N₂ : Type u_16
ι : Type u_17
V : Type u_18
V₂ : Type u_19
A : Type u_20
B : Type u_21
R : Type u_22
inst✝³ : Semiring R
inst✝² : AddCommGroup A
inst✝¹ : AddCommGroup B
inst✝ : Module R B
f : A →+ B
x✝ : A
⊢ (LinearMap.toAddMonoidHom
        (AddHom.toFun
          {
              toAddHom :=
                { toFun := AddMonoidHom.toIntLinearMap,
                  map_add' :=
                    (_ :
                      ∀ (x y : A →+ B),
                        AddMonoidHom.toIntLinearMap (x + y) =
                          AddMonoidHom.toIntLinearMap x + AddMonoidHom.toIntLinearMap y) },
              map_smul' :=
                (_ :
                  ∀ (r : R) (x : A →+ B),
                    AddHom.toFun
                        { toFun := AddMonoidHom.toIntLinearMap,
                          map_add' :=
                            (_ :
                              ∀ (x y : A →+ B),
                                AddMonoidHom.toIntLinearMap (x + y) =
                                  AddMonoidHom.toIntLinearMap x + AddMonoidHom.toIntLinearMap y) }
                        (r • x) =
                      (RingHom.id R) r •
                        AddHom.toFun
                          { toFun := AddMonoidHom.toIntLinearMap,
                            map_add' :=
                              (_ :
                                ∀ (x y : A →+ B),
                                  AddMonoidHom.toIntLinearMap (x + y) =
                                    AddMonoidHom.toIntLinearMap x + AddMonoidHom.toIntLinearMap y) }
                          x) }.toAddHom
          f))
      x✝ =
    f x✝

Next tactic:
rfl
/--
The `R`-linear equivalence between additive morphisms `A →+ B` and `ℤ`-linear morphisms `A →ₗ[ℤ] B`.
-/
@[simps]
def addMonoidHomLequivInt {A B : Type*} (R : Type*) [Semiring R] [AddCommGroup A] [AddCommGroup B]
    [Module R B] : (A →+ B) ≃ₗ[R] A →ₗ[ℤ] B
    where
  toFun := AddMonoidHom.toIntLinearMap
  invFun := LinearMap.toAddMonoidHom
  map_add' := by intros; ext; rfl
  map_smul' := by intros; ext; rfl
  left_inv := by intro f; ext; rfl
  right_inv := by 

Proof state:
R✝ : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
R₄ : Type u_5
S : Type u_6
K : Type u_7
K₂ : Type u_8
M : Type u_9
M' : Type u_10
M₁ : Type u_11
M₂ : Type u_12
M₃ : Type u_13
M₄ : Type u_14
N : Type u_15
N₂ : Type u_16
ι : Type u_17
V : Type u_18
V₂ : Type u_19
A : Type u_20
B : Type u_21
R : Type u_22
inst✝³ : Semiring R
inst✝² : AddCommGroup A
inst✝¹ : AddCommGroup B
inst✝ : Module R B
⊢ Function.RightInverse LinearMap.toAddMonoidHom
    {
          toAddHom :=
            { toFun := AddMonoidHom.toIntLinearMap,
              map_add' :=
                (_ :
                  ∀ (x y : A →+ B),
                    AddMonoidHom.toIntLinearMap (x + y) =
                      AddMonoidHom.toIntLinearMap x + AddMonoidHom.toIntLinearMap y) },
          map_smul' :=
            (_ :
              ∀ (r : R) (x : A →+ B),
                AddHom.toFun
                    { toFun := AddMonoidHom.toIntLinearMap,
                      map_add' :=
                        (_ :
                          ∀ (x y : A →+ B),
                            AddMonoidHom.toIntLinearMap (x + y) =
                              AddMonoidHom.toIntLinearMap x + AddMonoidHom.toIntLinearMap y) }
                    (r • x) =
                  (RingHom.id R) r •
                    AddHom.toFun
                      { toFun := AddMonoidHom.toIntLinearMap,
                        map_add' :=
                          (_ :
                            ∀ (x y : A →+ B),
                              AddMonoidHom.toIntLinearMap (x + y) =
                                AddMonoidHom.toIntLinearMap x + AddMonoidHom.toIntLinearMap y) }
                      x) }.toAddHom.toFun

Next tactic:
intro f
/--
The `R`-linear equivalence between additive morphisms `A →+ B` and `ℤ`-linear morphisms `A →ₗ[ℤ] B`.
-/
@[simps]
def addMonoidHomLequivInt {A B : Type*} (R : Type*) [Semiring R] [AddCommGroup A] [AddCommGroup B]
    [Module R B] : (A →+ B) ≃ₗ[R] A →ₗ[ℤ] B
    where
  toFun := AddMonoidHom.toIntLinearMap
  invFun := LinearMap.toAddMonoidHom
  map_add' := by intros; ext; rfl
  map_smul' := by intros; ext; rfl
  left_inv := by intro f; ext; rfl
  right_inv := by intro f; 

Proof state:
R✝ : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
R₄ : Type u_5
S : Type u_6
K : Type u_7
K₂ : Type u_8
M : Type u_9
M' : Type u_10
M₁ : Type u_11
M₂ : Type u_12
M₃ : Type u_13
M₄ : Type u_14
N : Type u_15
N₂ : Type u_16
ι : Type u_17
V : Type u_18
V₂ : Type u_19
A : Type u_20
B : Type u_21
R : Type u_22
inst✝³ : Semiring R
inst✝² : AddCommGroup A
inst✝¹ : AddCommGroup B
inst✝ : Module R B
f : A →ₗ[ℤ] B
⊢ AddHom.toFun
      {
          toAddHom :=
            { toFun := AddMonoidHom.toIntLinearMap,
              map_add' :=
                (_ :
                  ∀ (x y : A →+ B),
                    AddMonoidHom.toIntLinearMap (x + y) =
                      AddMonoidHom.toIntLinearMap x + AddMonoidHom.toIntLinearMap y) },
          map_smul' :=
            (_ :
              ∀ (r : R) (x : A →+ B),
                AddHom.toFun
                    { toFun := AddMonoidHom.toIntLinearMap,
                      map_add' :=
                        (_ :
                          ∀ (x y : A →+ B),
                            AddMonoidHom.toIntLinearMap (x + y) =
                              AddMonoidHom.toIntLinearMap x + AddMonoidHom.toIntLinearMap y) }
                    (r • x) =
                  (RingHom.id R) r •
                    AddHom.toFun
                      { toFun := AddMonoidHom.toIntLinearMap,
                        map_add' :=
                          (_ :
                            ∀ (x y : A →+ B),
                              AddMonoidHom.toIntLinearMap (x + y) =
                                AddMonoidHom.toIntLinearMap x + AddMonoidHom.toIntLinearMap y) }
                      x) }.toAddHom
      (LinearMap.toAddMonoidHom f) =
    f

Next tactic:
ext
/--
The `R`-linear equivalence between additive morphisms `A →+ B` and `ℤ`-linear morphisms `A →ₗ[ℤ] B`.
-/
@[simps]
def addMonoidHomLequivInt {A B : Type*} (R : Type*) [Semiring R] [AddCommGroup A] [AddCommGroup B]
    [Module R B] : (A →+ B) ≃ₗ[R] A →ₗ[ℤ] B
    where
  toFun := AddMonoidHom.toIntLinearMap
  invFun := LinearMap.toAddMonoidHom
  map_add' := by intros; ext; rfl
  map_smul' := by intros; ext; rfl
  left_inv := by intro f; ext; rfl
  right_inv := by intro f; ext; 

Proof state:
case h
R✝ : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
R₄ : Type u_5
S : Type u_6
K : Type u_7
K₂ : Type u_8
M : Type u_9
M' : Type u_10
M₁ : Type u_11
M₂ : Type u_12
M₃ : Type u_13
M₄ : Type u_14
N : Type u_15
N₂ : Type u_16
ι : Type u_17
V : Type u_18
V₂ : Type u_19
A : Type u_20
B : Type u_21
R : Type u_22
inst✝³ : Semiring R
inst✝² : AddCommGroup A
inst✝¹ : AddCommGroup B
inst✝ : Module R B
f : A →ₗ[ℤ] B
x✝ : A
⊢ (AddHom.toFun
        {
            toAddHom :=
              { toFun := AddMonoidHom.toIntLinearMap,
                map_add' :=
                  (_ :
                    ∀ (x y : A →+ B),
                      AddMonoidHom.toIntLinearMap (x + y) =
                        AddMonoidHom.toIntLinearMap x + AddMonoidHom.toIntLinearMap y) },
            map_smul' :=
              (_ :
                ∀ (r : R) (x : A →+ B),
                  AddHom.toFun
                      { toFun := AddMonoidHom.toIntLinearMap,
                        map_add' :=
                          (_ :
                            ∀ (x y : A →+ B),
                              AddMonoidHom.toIntLinearMap (x + y) =
                                AddMonoidHom.toIntLinearMap x + AddMonoidHom.toIntLinearMap y) }
                      (r • x) =
                    (RingHom.id R) r •
                      AddHom.toFun
                        { toFun := AddMonoidHom.toIntLinearMap,
                          map_add' :=
                            (_ :
                              ∀ (x y : A →+ B),
                                AddMonoidHom.toIntLinearMap (x + y) =
                                  AddMonoidHom.toIntLinearMap x + AddMonoidHom.toIntLinearMap y) }
                        x) }.toAddHom
        (LinearMap.toAddMonoidHom f))
      x✝ =
    f x✝

Next tactic:
rfl
theorem map_codRestrict [RingHomSurjective σ₂₁] (p : Submodule R M) (f : M₂ →ₛₗ[σ₂₁] M) (h p') :
    Submodule.map (codRestrict p f h) p' = comap p.subtype (p'.map f) :=
  Submodule.ext fun ⟨x, hx⟩ => by 

Proof state:
R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
R₄ : Type u_5
S : Type u_6
K : Type u_7
K₂ : Type u_8
M : Type u_9
M' : Type u_10
M₁ : Type u_11
M₂ : Type u_12
M₃ : Type u_13
M₄ : Type u_14
N : Type u_15
N₂ : Type u_16
ι : Type u_17
V : Type u_18
V₂ : Type u_19
inst✝¹¹ : Semiring R
inst✝¹⁰ : Semiring R₂
inst✝⁹ : Semiring R₃
inst✝⁸ : AddCommMonoid M
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : AddCommMonoid M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁵ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝⁴ : Module R M
inst✝³ : Module R₂ M₂
inst✝² : Module R₃ M₃
σ₂₁ : R₂ →+* R
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝¹ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
inst✝ : RingHomSurjective σ₂₁
p : Submodule R M
f : M₂ →ₛₗ[σ₂₁] M
h : ∀ (c : M₂), f c ∈ p
p' : Submodule R₂ M₂
x✝ : ↥p
x : M
hx : x ∈ p
⊢ { val := x, property := hx } ∈ map (codRestrict p f h) p' ↔
    { val := x, property := hx } ∈ comap (Submodule.subtype p) (map f p')

Next tactic:
simp [Subtype.ext_iff_val]
theorem comap_codRestrict (p : Submodule R M) (f : M₂ →ₛₗ[σ₂₁] M) (hf p') :
    Submodule.comap (codRestrict p f hf) p' = Submodule.comap f (map p.subtype p') :=
  Submodule.ext fun x => ⟨fun h => ⟨⟨_, hf x⟩, h, rfl⟩, by 

Proof state:
R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
R₄ : Type u_5
S : Type u_6
K : Type u_7
K₂ : Type u_8
M : Type u_9
M' : Type u_10
M₁ : Type u_11
M₂ : Type u_12
M₃ : Type u_13
M₄ : Type u_14
N : Type u_15
N₂ : Type u_16
ι : Type u_17
V : Type u_18
V₂ : Type u_19
inst✝¹⁰ : Semiring R
inst✝⁹ : Semiring R₂
inst✝⁸ : Semiring R₃
inst✝⁷ : AddCommMonoid M
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : AddCommMonoid M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁴ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝³ : Module R M
inst✝² : Module R₂ M₂
inst✝¹ : Module R₃ M₃
σ₂₁ : R₂ →+* R
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
p : Submodule R M
f : M₂ →ₛₗ[σ₂₁] M
hf : ∀ (c : M₂), f c ∈ p
p' : Submodule R ↥p
x : M₂
⊢ x ∈ comap f (map (Submodule.subtype p) p') → x ∈ comap (codRestrict p f hf) p'

Next tactic:
rintro ⟨⟨_, _⟩, h, ⟨⟩⟩
theorem comap_codRestrict (p : Submodule R M) (f : M₂ →ₛₗ[σ₂₁] M) (hf p') :
    Submodule.comap (codRestrict p f hf) p' = Submodule.comap f (map p.subtype p') :=
  Submodule.ext fun x => ⟨fun h => ⟨⟨_, hf x⟩, h, rfl⟩, by rintro ⟨⟨_, _⟩, h, ⟨⟩⟩; 

Proof state:
case intro.mk.intro.refl
R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
R₄ : Type u_5
S : Type u_6
K : Type u_7
K₂ : Type u_8
M : Type u_9
M' : Type u_10
M₁ : Type u_11
M₂ : Type u_12
M₃ : Type u_13
M₄ : Type u_14
N : Type u_15
N₂ : Type u_16
ι : Type u_17
V : Type u_18
V₂ : Type u_19
inst✝¹⁰ : Semiring R
inst✝⁹ : Semiring R₂
inst✝⁸ : Semiring R₃
inst✝⁷ : AddCommMonoid M
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : AddCommMonoid M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁴ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝³ : Module R M
inst✝² : Module R₂ M₂
inst✝¹ : Module R₃ M₃
σ₂₁ : R₂ →+* R
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
p : Submodule R M
f : M₂ →ₛₗ[σ₂₁] M
hf : ∀ (c : M₂), f c ∈ p
p' : Submodule R ↥p
x : M₂
property✝ : f.toAddHom.1 x ∈ p
h : { val := f.toAddHom.1 x, property := property✝ } ∈ ↑p'
⊢ x ∈ comap (codRestrict p f hf) p'

Next tactic:
exact h
theorem range_eq_map [RingHomSurjective τ₁₂] (f : F) : range f = map f ⊤ := by
  

Proof state:
R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
R₄ : Type u_5
S : Type u_6
K : Type u_7
K₂ : Type u_8
M : Type u_9
M' : Type u_10
M₁ : Type u_11
M₂ : Type u_12
M₃ : Type u_13
M₄ : Type u_14
N : Type u_15
N₂ : Type u_16
ι : Type u_17
V : Type u_18
V₂ : Type u_19
inst✝¹¹ : Semiring R
inst✝¹⁰ : Semiring R₂
inst✝⁹ : Semiring R₃
inst✝⁸ : AddCommMonoid M
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : AddCommMonoid M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁵ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝⁴ : Module R M
inst✝³ : Module R₂ M₂
inst✝² : Module R₃ M₃
σ₂₁ : R₂ →+* R
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝¹ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
F : Type u_20
sc : SemilinearMapClass F τ₁₂ M M₂
inst✝ : RingHomSurjective τ₁₂
f : F
⊢ range f = map f ⊤

Next tactic:
ext
theorem range_eq_map [RingHomSurjective τ₁₂] (f : F) : range f = map f ⊤ := by
  ext
  

Proof state:
case h
R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
R₄ : Type u_5
S : Type u_6
K : Type u_7
K₂ : Type u_8
M : Type u_9
M' : Type u_10
M₁ : Type u_11
M₂ : Type u_12
M₃ : Type u_13
M₄ : Type u_14
N : Type u_15
N₂ : Type u_16
ι : Type u_17
V : Type u_18
V₂ : Type u_19
inst✝¹¹ : Semiring R
inst✝¹⁰ : Semiring R₂
inst✝⁹ : Semiring R₃
inst✝⁸ : AddCommMonoid M
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : AddCommMonoid M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁵ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝⁴ : Module R M
inst✝³ : Module R₂ M₂
inst✝² : Module R₃ M₃
σ₂₁ : R₂ →+* R
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝¹ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
F : Type u_20
sc : SemilinearMapClass F τ₁₂ M M₂
inst✝ : RingHomSurjective τ₁₂
f : F
x✝ : M₂
⊢ x✝ ∈ range f ↔ x✝ ∈ map f ⊤

Next tactic:
simp
theorem range_eq_top [RingHomSurjective τ₁₂] {f : F} : range f = ⊤ ↔ Surjective f := by
  

Proof state:
R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
R₄ : Type u_5
S : Type u_6
K : Type u_7
K₂ : Type u_8
M : Type u_9
M' : Type u_10
M₁ : Type u_11
M₂ : Type u_12
M₃ : Type u_13
M₄ : Type u_14
N : Type u_15
N₂ : Type u_16
ι : Type u_17
V : Type u_18
V₂ : Type u_19
inst✝¹¹ : Semiring R
inst✝¹⁰ : Semiring R₂
inst✝⁹ : Semiring R₃
inst✝⁸ : AddCommMonoid M
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : AddCommMonoid M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁵ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝⁴ : Module R M
inst✝³ : Module R₂ M₂
inst✝² : Module R₃ M₃
σ₂₁ : R₂ →+* R
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝¹ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
F : Type u_20
sc : SemilinearMapClass F τ₁₂ M M₂
inst✝ : RingHomSurjective τ₁₂
f : F
⊢ range f = ⊤ ↔ Surjective ⇑f

Next tactic:
rw [SetLike.ext'_iff, range_coe, top_coe, Set.range_iff_surjective]
theorem range_le_iff_comap [RingHomSurjective τ₁₂] {f : F} {p : Submodule R₂ M₂} :
    range f ≤ p ↔ comap f p = ⊤ := by 

Proof state:
R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
R₄ : Type u_5
S : Type u_6
K : Type u_7
K₂ : Type u_8
M : Type u_9
M' : Type u_10
M₁ : Type u_11
M₂ : Type u_12
M₃ : Type u_13
M₄ : Type u_14
N : Type u_15
N₂ : Type u_16
ι : Type u_17
V : Type u_18
V₂ : Type u_19
inst✝¹¹ : Semiring R
inst✝¹⁰ : Semiring R₂
inst✝⁹ : Semiring R₃
inst✝⁸ : AddCommMonoid M
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : AddCommMonoid M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁵ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝⁴ : Module R M
inst✝³ : Module R₂ M₂
inst✝² : Module R₃ M₃
σ₂₁ : R₂ →+* R
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝¹ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
F : Type u_20
sc : SemilinearMapClass F τ₁₂ M M₂
inst✝ : RingHomSurjective τ₁₂
f : F
p : Submodule R₂ M₂
⊢ range f ≤ p ↔ comap f p = ⊤

Next tactic:
rw [range_eq_map, map_le_iff_le_comap, eq_top_iff]
@[simp]
theorem range_neg {R : Type*} {R₂ : Type*} {M : Type*} {M₂ : Type*} [Semiring R] [Ring R₂]
    [AddCommMonoid M] [AddCommGroup M₂] [Module R M] [Module R₂ M₂] {τ₁₂ : R →+* R₂}
    [RingHomSurjective τ₁₂] (f : M →ₛₗ[τ₁₂] M₂) : LinearMap.range (-f) = LinearMap.range f := by
  

Proof state:
R✝ : Type u_1
R₁ : Type u_2
R₂✝ : Type u_3
R₃ : Type u_4
R₄ : Type u_5
S : Type u_6
K : Type u_7
K₂ : Type u_8
M✝ : Type u_9
M' : Type u_10
M₁ : Type u_11
M₂✝ : Type u_12
M₃ : Type u_13
M₄ : Type u_14
N : Type u_15
N₂ : Type u_16
ι : Type u_17
V : Type u_18
V₂ : Type u_19
inst✝¹⁷ : Semiring R✝
inst✝¹⁶ : Semiring R₂✝
inst✝¹⁵ : Semiring R₃
inst✝¹⁴ : AddCommMonoid M✝
inst✝¹³ : AddCommMonoid M₂✝
inst✝¹² : AddCommMonoid M₃
σ₁₂ : R✝ →+* R₂✝
σ₂₃ : R₂✝ →+* R₃
σ₁₃ : R✝ →+* R₃
inst✝¹¹ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝¹⁰ : Module R✝ M✝
inst✝⁹ : Module R₂✝ M₂✝
inst✝⁸ : Module R₃ M₃
σ₂₁ : R₂✝ →+* R✝
τ₁₂✝ : R✝ →+* R₂✝
τ₂₃ : R₂✝ →+* R₃
τ₁₃ : R✝ →+* R₃
inst✝⁷ : RingHomCompTriple τ₁₂✝ τ₂₃ τ₁₃
F : Type u_20
sc : SemilinearMapClass F τ₁₂✝ M✝ M₂✝
R : Type u_21
R₂ : Type u_22
M : Type u_23
M₂ : Type u_24
inst✝⁶ : Semiring R
inst✝⁵ : Ring R₂
inst✝⁴ : AddCommMonoid M
inst✝³ : AddCommGroup M₂
inst✝² : Module R M
inst✝¹ : Module R₂ M₂
τ₁₂ : R →+* R₂
inst✝ : RingHomSurjective τ₁₂
f : M →ₛₗ[τ₁₂] M₂
⊢ range (-f) = range f

Next tactic:
change range ((-LinearMap.id : M₂ →ₗ[R₂] M₂).comp f) = _