File: Mathlib/Topology/Instances/Matrix.lean

full_name: instTopologicalSpaceMatrix
code: instance [TopologicalSpace R] : TopologicalSpace (Matrix m n R) 
goal: TopologicalSpace (Matrix m n R)

full_name: instT2SpaceMatrix
code: instance [TopologicalSpace R] [T2Space R] : T2Space (Matrix m n R) 
goal: T2Space (Matrix m n R)

full_name: instContinuousConstSMulMatrix
code: instance [SMul α R] [ContinuousConstSMul α R] : ContinuousConstSMul α (Matrix m n R) 
goal: ContinuousConstSMul α (Matrix m n R)

full_name: instContinuousSMulMatrix
code: instance [TopologicalSpace α] [SMul α R] [ContinuousSMul α R] : ContinuousSMul α (Matrix m n R) 
goal: ContinuousSMul α (Matrix m n R)

full_name: instContinuousAddMatrix
code: instance [Add R] [ContinuousAdd R] : ContinuousAdd (Matrix m n R) 
goal: ContinuousAdd (Matrix m n R)

full_name: instContinuousNegMatrix
code: instance [Neg R] [ContinuousNeg R] : ContinuousNeg (Matrix m n R) 
goal: ContinuousNeg (Matrix m n R)

full_name: instTopologicalAddGroupMatrix
code: instance [AddGroup R] [TopologicalAddGroup R] : TopologicalAddGroup (Matrix m n R) 
goal: TopologicalAddGroup (Matrix m n R)

full_name: continuous_matrix
code: /-- To show a function into matrices is continuous it suffices to show the coefficients of the
resulting matrix are continuous -/
@[continuity]
theorem continuous_matrix [TopologicalSpace α] {f : α → Matrix m n R}
    (h : ∀ i j, Continuous fun a => f a i j) : Continuous f 
goal: Continuous f

full_name: Continuous.matrix_elem
code: theorem Continuous.matrix_elem {A : X → Matrix m n R} (hA : Continuous A) (i : m) (j : n) :
    Continuous fun x => A x i j 
goal: Continuous fun x => A x i j

full_name: Continuous.matrix_map
code: @[continuity]
theorem Continuous.matrix_map [TopologicalSpace S] {A : X → Matrix m n S} {f : S → R}
    (hA : Continuous A) (hf : Continuous f) : Continuous fun x => (A x).map f 
goal: Continuous fun x => (A x).map f

full_name: Continuous.matrix_transpose
code: @[continuity]
theorem Continuous.matrix_transpose {A : X → Matrix m n R} (hA : Continuous A) :
    Continuous fun x => (A x)ᵀ 
goal: Continuous fun x => (A x)ᵀ

full_name: Continuous.matrix_conjTranspose
code: theorem Continuous.matrix_conjTranspose [Star R] [ContinuousStar R] {A : X → Matrix m n R}
    (hA : Continuous A) : Continuous fun x => (A x)ᴴ 
goal: Continuous fun x => (A x)ᴴ

full_name: instContinuousStarMatrix
code: instance [Star R] [ContinuousStar R] : ContinuousStar (Matrix m m R) 
goal: ContinuousStar (Matrix m m R)

full_name: Continuous.matrix_col
code: @[continuity]
theorem Continuous.matrix_col {ι : Type*} {A : X → n → R} (hA : Continuous A) :
    Continuous fun x => col ι (A x) 
goal: Continuous fun x => Matrix.col ι (A x)

full_name: Continuous.matrix_row
code: @[continuity]
theorem Continuous.matrix_row {ι : Type*} {A : X → n → R} (hA : Continuous A) :
    Continuous fun x => row ι (A x) 
goal: Continuous fun x => Matrix.row ι (A x)

full_name: Continuous.matrix_diagonal
code: @[continuity]
theorem Continuous.matrix_diagonal [Zero R] [DecidableEq n] {A : X → n → R} (hA : Continuous A) :
    Continuous fun x => diagonal (A x) 
goal: Continuous fun x => Matrix.diagonal (A x)

full_name: Continuous.matrix_dotProduct
code: @[continuity]
theorem Continuous.matrix_dotProduct [Fintype n] [Mul R] [AddCommMonoid R] [ContinuousAdd R]
    [ContinuousMul R] {A : X → n → R} {B : X → n → R} (hA : Continuous A) (hB : Continuous B) :
    Continuous fun x => dotProduct (A x) (B x) 
goal: Continuous fun x => A x ⬝ᵥ B x

full_name: Continuous.matrix_mul
code: /-- For square matrices the usual `continuous_mul` can be used. -/
@[continuity]
theorem Continuous.matrix_mul [Fintype n] [Mul R] [AddCommMonoid R] [ContinuousAdd R]
    [ContinuousMul R] {A : X → Matrix m n R} {B : X → Matrix n p R} (hA : Continuous A)
    (hB : Continuous B) : Continuous fun x => A x * B x 
goal: Continuous fun x => A x * B x

full_name: instContinuousMulMatrixOfContinuousAdd
code: instance [Fintype n] [Mul R] [AddCommMonoid R] [ContinuousAdd R] [ContinuousMul R] :
    ContinuousMul (Matrix n n R) 
goal: ContinuousMul (Matrix n n R)

full_name: instTopologicalSemiringMatrix
code: instance [Fintype n] [NonUnitalNonAssocSemiring R] [TopologicalSemiring R] :
    TopologicalSemiring (Matrix n n R) 
goal: TopologicalSemiring (Matrix n n R)

full_name: Matrix.topologicalRing
code: instance Matrix.topologicalRing [Fintype n] [NonUnitalNonAssocRing R] [TopologicalRing R] :
    TopologicalRing (Matrix n n R) 
goal: TopologicalRing (Matrix n n R)

full_name: Continuous.matrix_vecMulVec
code: @[continuity]
theorem Continuous.matrix_vecMulVec [Mul R] [ContinuousMul R] {A : X → m → R} {B : X → n → R}
    (hA : Continuous A) (hB : Continuous B) : Continuous fun x => vecMulVec (A x) (B x) 
goal: Continuous fun x => Matrix.vecMulVec (A x) (B x)

full_name: Continuous.matrix_mulVec
code: @[continuity]
theorem Continuous.matrix_mulVec [NonUnitalNonAssocSemiring R] [ContinuousAdd R] [ContinuousMul R]
    [Fintype n] {A : X → Matrix m n R} {B : X → n → R} (hA : Continuous A) (hB : Continuous B) :
    Continuous fun x => A x *ᵥ B x 
goal: Continuous fun x => A x *ᵥ B x

full_name: Continuous.matrix_vecMul
code: @[continuity]
theorem Continuous.matrix_vecMul [NonUnitalNonAssocSemiring R] [ContinuousAdd R] [ContinuousMul R]
    [Fintype m] {A : X → m → R} {B : X → Matrix m n R} (hA : Continuous A) (hB : Continuous B) :
    Continuous fun x => A x ᵥ* B x 
goal: Continuous fun x => A x ᵥ* B x

full_name: Continuous.matrix_submatrix
code: @[continuity]
theorem Continuous.matrix_submatrix {A : X → Matrix l n R} (hA : Continuous A) (e₁ : m → l)
    (e₂ : p → n) : Continuous fun x => (A x).submatrix e₁ e₂ 
goal: Continuous fun x => (A x).submatrix e₁ e₂

full_name: Continuous.matrix_reindex
code: @[continuity]
theorem Continuous.matrix_reindex {A : X → Matrix l n R} (hA : Continuous A) (e₁ : l ≃ m)
    (e₂ : n ≃ p) : Continuous fun x => reindex e₁ e₂ (A x) 
goal: Continuous fun x => (Matrix.reindex e₁ e₂) (A x)

full_name: Continuous.matrix_diag
code: @[continuity]
theorem Continuous.matrix_diag {A : X → Matrix n n R} (hA : Continuous A) :
    Continuous fun x => Matrix.diag (A x) 
goal: Continuous fun x => (A x).diag

full_name: continuous_matrix_diag
code: theorem continuous_matrix_diag : Continuous (Matrix.diag : Matrix n n R → n → R) 
goal: Continuous Matrix.diag

full_name: Continuous.matrix_trace
code: @[continuity]
theorem Continuous.matrix_trace [Fintype n] [AddCommMonoid R] [ContinuousAdd R]
    {A : X → Matrix n n R} (hA : Continuous A) : Continuous fun x => trace (A x) 
goal: Continuous fun x => (A x).trace

full_name: Continuous.matrix_det
code: @[continuity]
theorem Continuous.matrix_det [Fintype n] [DecidableEq n] [CommRing R] [TopologicalRing R]
    {A : X → Matrix n n R} (hA : Continuous A) : Continuous fun x => (A x).det 
goal: Continuous fun x => (A x).det

full_name: Continuous.matrix_updateColumn
code: @[continuity]
theorem Continuous.matrix_updateColumn [DecidableEq n] (i : n) {A : X → Matrix m n R}
    {B : X → m → R} (hA : Continuous A) (hB : Continuous B) :
    Continuous fun x => (A x).updateColumn i (B x) 
goal: Continuous fun x => (A x).updateColumn i (B x)

full_name: Continuous.matrix_updateRow
code: @[continuity]
theorem Continuous.matrix_updateRow [DecidableEq m] (i : m) {A : X → Matrix m n R} {B : X → n → R}
    (hA : Continuous A) (hB : Continuous B) : Continuous fun x => (A x).updateRow i (B x) 
goal: Continuous fun x => (A x).updateRow i (B x)

full_name: Continuous.matrix_cramer
code: @[continuity]
theorem Continuous.matrix_cramer [Fintype n] [DecidableEq n] [CommRing R] [TopologicalRing R]
    {A : X → Matrix n n R} {B : X → n → R} (hA : Continuous A) (hB : Continuous B) :
    Continuous fun x => cramer (A x) (B x) 
goal: Continuous fun x => (A x).cramer (B x)

full_name: Continuous.matrix_adjugate
code: @[continuity]
theorem Continuous.matrix_adjugate [Fintype n] [DecidableEq n] [CommRing R] [TopologicalRing R]
    {A : X → Matrix n n R} (hA : Continuous A) : Continuous fun x => (A x).adjugate 
goal: Continuous fun x => (A x).adjugate

full_name: continuousAt_matrix_inv
code: /-- When `Ring.inverse` is continuous at the determinant (such as in a `NormedRing`, or a
topological field), so is `Matrix.inv`. -/
theorem continuousAt_matrix_inv [Fintype n] [DecidableEq n] [CommRing R] [TopologicalRing R]
    (A : Matrix n n R) (h : ContinuousAt Ring.inverse A.det) : ContinuousAt Inv.inv A 
goal: ContinuousAt Inv.inv A

full_name: Continuous.matrix_fromBlocks
code: @[continuity]
theorem Continuous.matrix_fromBlocks {A : X → Matrix n l R} {B : X → Matrix n m R}
    {C : X → Matrix p l R} {D : X → Matrix p m R} (hA : Continuous A) (hB : Continuous B)
    (hC : Continuous C) (hD : Continuous D) :
    Continuous fun x => Matrix.fromBlocks (A x) (B x) (C x) (D x) 
goal: Continuous fun x => Matrix.fromBlocks (A x) (B x) (C x) (D x)

full_name: Continuous.matrix_blockDiagonal
code: @[continuity]
theorem Continuous.matrix_blockDiagonal [Zero R] [DecidableEq p] {A : X → p → Matrix m n R}
    (hA : Continuous A) : Continuous fun x => blockDiagonal (A x) 
goal: Continuous fun x => Matrix.blockDiagonal (A x)

full_name: Continuous.matrix_blockDiag
code: @[continuity]
theorem Continuous.matrix_blockDiag {A : X → Matrix (m × p) (n × p) R} (hA : Continuous A) :
    Continuous fun x => blockDiag (A x) 
goal: Continuous fun x => (A x).blockDiag

full_name: Continuous.matrix_blockDiagonal'
code: @[continuity]
theorem Continuous.matrix_blockDiagonal' [Zero R] [DecidableEq l]
    {A : X → ∀ i, Matrix (m' i) (n' i) R} (hA : Continuous A) :
    Continuous fun x => blockDiagonal' (A x) 
goal: Continuous fun x => Matrix.blockDiagonal' (A x)

full_name: Continuous.matrix_blockDiag'
code: @[continuity]
theorem Continuous.matrix_blockDiag' {A : X → Matrix (Σi, m' i) (Σi, n' i) R} (hA : Continuous A) :
    Continuous fun x => blockDiag' (A x) 
goal: Continuous fun x => (A x).blockDiag'

full_name: HasSum.matrix_transpose
code: theorem HasSum.matrix_transpose {f : X → Matrix m n R} {a : Matrix m n R} (hf : HasSum f a) :
    HasSum (fun x => (f x)ᵀ) aᵀ 
goal: HasSum (fun x => (f x)ᵀ) aᵀ

full_name: Summable.matrix_transpose
code: theorem Summable.matrix_transpose {f : X → Matrix m n R} (hf : Summable f) :
    Summable fun x => (f x)ᵀ 
goal: Summable fun x => (f x)ᵀ

full_name: summable_matrix_transpose
code: @[simp]
theorem summable_matrix_transpose {f : X → Matrix m n R} :
    (Summable fun x => (f x)ᵀ) ↔ Summable f 
goal: (Summable fun x => (f x)ᵀ) ↔ Summable f

full_name: Matrix.transpose_tsum
code: theorem Matrix.transpose_tsum [T2Space R] {f : X → Matrix m n R} : (∑' x, f x)ᵀ = ∑' x, (f x)ᵀ 
goal: (∑' (x : X), f x)ᵀ = ∑' (x : X), (f x)ᵀ

full_name: HasSum.matrix_conjTranspose
code: theorem HasSum.matrix_conjTranspose [StarAddMonoid R] [ContinuousStar R] {f : X → Matrix m n R}
    {a : Matrix m n R} (hf : HasSum f a) : HasSum (fun x => (f x)ᴴ) aᴴ 
goal: HasSum (fun x => (f x)ᴴ) aᴴ

full_name: Summable.matrix_conjTranspose
code: theorem Summable.matrix_conjTranspose [StarAddMonoid R] [ContinuousStar R] {f : X → Matrix m n R}
    (hf : Summable f) : Summable fun x => (f x)ᴴ 
goal: Summable fun x => (f x)ᴴ

full_name: summable_matrix_conjTranspose
code: @[simp]
theorem summable_matrix_conjTranspose [StarAddMonoid R] [ContinuousStar R] {f : X → Matrix m n R} :
    (Summable fun x => (f x)ᴴ) ↔ Summable f 
goal: (Summable fun x => (f x)ᴴ) ↔ Summable f

full_name: Matrix.conjTranspose_tsum
code: theorem Matrix.conjTranspose_tsum [StarAddMonoid R] [ContinuousStar R] [T2Space R]
    {f : X → Matrix m n R} : (∑' x, f x)ᴴ = ∑' x, (f x)ᴴ 
goal: (∑' (x : X), f x)ᴴ = ∑' (x : X), (f x)ᴴ

full_name: HasSum.matrix_diagonal
code: theorem HasSum.matrix_diagonal [DecidableEq n] {f : X → n → R} {a : n → R} (hf : HasSum f a) :
    HasSum (fun x => diagonal (f x)) (diagonal a) 
goal: HasSum (fun x => Matrix.diagonal (f x)) (Matrix.diagonal a)

full_name: Summable.matrix_diagonal
code: theorem Summable.matrix_diagonal [DecidableEq n] {f : X → n → R} (hf : Summable f) :
    Summable fun x => diagonal (f x) 
goal: Summable fun x => Matrix.diagonal (f x)

full_name: summable_matrix_diagonal
code: @[simp]
theorem summable_matrix_diagonal [DecidableEq n] {f : X → n → R} :
    (Summable fun x => diagonal (f x)) ↔ Summable f 
goal: (Summable fun x => Matrix.diagonal (f x)) ↔ Summable f

full_name: Matrix.diagonal_tsum
code: theorem Matrix.diagonal_tsum [DecidableEq n] [T2Space R] {f : X → n → R} :
    diagonal (∑' x, f x) = ∑' x, diagonal (f x) 
goal: Matrix.diagonal (∑' (x : X), f x) = ∑' (x : X), Matrix.diagonal (f x)

full_name: HasSum.matrix_diag
code: theorem HasSum.matrix_diag {f : X → Matrix n n R} {a : Matrix n n R} (hf : HasSum f a) :
    HasSum (fun x => diag (f x)) (diag a) 
goal: HasSum (fun x => (f x).diag) a.diag

full_name: Summable.matrix_diag
code: theorem Summable.matrix_diag {f : X → Matrix n n R} (hf : Summable f) :
    Summable fun x => diag (f x) 
goal: Summable fun x => (f x).diag

full_name: HasSum.matrix_blockDiagonal
code: theorem HasSum.matrix_blockDiagonal [DecidableEq p] {f : X → p → Matrix m n R}
    {a : p → Matrix m n R} (hf : HasSum f a) :
    HasSum (fun x => blockDiagonal (f x)) (blockDiagonal a) 
goal: HasSum (fun x => Matrix.blockDiagonal (f x)) (Matrix.blockDiagonal a)

full_name: Summable.matrix_blockDiagonal
code: theorem Summable.matrix_blockDiagonal [DecidableEq p] {f : X → p → Matrix m n R} (hf : Summable f) :
    Summable fun x => blockDiagonal (f x) 
goal: Summable fun x => Matrix.blockDiagonal (f x)

full_name: summable_matrix_blockDiagonal
code: theorem summable_matrix_blockDiagonal [DecidableEq p] {f : X → p → Matrix m n R} :
    (Summable fun x => blockDiagonal (f x)) ↔ Summable f 
goal: (Summable fun x => Matrix.blockDiagonal (f x)) ↔ Summable f

full_name: Matrix.blockDiagonal_tsum
code: theorem Matrix.blockDiagonal_tsum [DecidableEq p] [T2Space R] {f : X → p → Matrix m n R} :
    blockDiagonal (∑' x, f x) = ∑' x, blockDiagonal (f x) 
goal: Matrix.blockDiagonal (∑' (x : X), f x) = ∑' (x : X), Matrix.blockDiagonal (f x)

full_name: HasSum.matrix_blockDiag
code: theorem HasSum.matrix_blockDiag {f : X → Matrix (m × p) (n × p) R} {a : Matrix (m × p) (n × p) R}
    (hf : HasSum f a) : HasSum (fun x => blockDiag (f x)) (blockDiag a) 
goal: HasSum (fun x => (f x).blockDiag) a.blockDiag

full_name: Summable.matrix_blockDiag
code: theorem Summable.matrix_blockDiag {f : X → Matrix (m × p) (n × p) R} (hf : Summable f) :
    Summable fun x => blockDiag (f x) 
goal: Summable fun x => (f x).blockDiag

full_name: HasSum.matrix_blockDiagonal'
code: theorem HasSum.matrix_blockDiagonal' [DecidableEq l] {f : X → ∀ i, Matrix (m' i) (n' i) R}
    {a : ∀ i, Matrix (m' i) (n' i) R} (hf : HasSum f a) :
    HasSum (fun x => blockDiagonal' (f x)) (blockDiagonal' a) 
goal: HasSum (fun x => Matrix.blockDiagonal' (f x)) (Matrix.blockDiagonal' a)

full_name: Summable.matrix_blockDiagonal'
code: theorem Summable.matrix_blockDiagonal' [DecidableEq l] {f : X → ∀ i, Matrix (m' i) (n' i) R}
    (hf : Summable f) : Summable fun x => blockDiagonal' (f x) 
goal: Summable fun x => Matrix.blockDiagonal' (f x)

full_name: summable_matrix_blockDiagonal'
code: theorem summable_matrix_blockDiagonal' [DecidableEq l] {f : X → ∀ i, Matrix (m' i) (n' i) R} :
    (Summable fun x => blockDiagonal' (f x)) ↔ Summable f 
goal: (Summable fun x => Matrix.blockDiagonal' (f x)) ↔ Summable f

full_name: Matrix.blockDiagonal'_tsum
code: theorem Matrix.blockDiagonal'_tsum [DecidableEq l] [T2Space R]
    {f : X → ∀ i, Matrix (m' i) (n' i) R} :
    blockDiagonal' (∑' x, f x) = ∑' x, blockDiagonal' (f x) 
goal: Matrix.blockDiagonal' (∑' (x : X), f x) = ∑' (x : X), Matrix.blockDiagonal' (f x)

full_name: HasSum.matrix_blockDiag'
code: theorem HasSum.matrix_blockDiag' {f : X → Matrix (Σi, m' i) (Σi, n' i) R}
    {a : Matrix (Σi, m' i) (Σi, n' i) R} (hf : HasSum f a) :
    HasSum (fun x => blockDiag' (f x)) (blockDiag' a) 
goal: HasSum (fun x => (f x).blockDiag') a.blockDiag'

full_name: Summable.matrix_blockDiag'
code: theorem Summable.matrix_blockDiag' {f : X → Matrix (Σi, m' i) (Σi, n' i) R} (hf : Summable f) :
    Summable fun x => blockDiag' (f x) 
goal: Summable fun x => (f x).blockDiag'