Summary  
This chapter covers how to perform matrix multiplication by ensuring dimension compatibility and using efficient operations (such as the @ operator or dot function) to compute the dot products of rows and columns.  

General domain of usage  
Machine learning

This video introduces the foundational rules of matrix multiplication, focusing on **dimension compatibility**, how to compute the product using the **dot product** with numpy and @ operation, and practical real-world applications such as computer graphics, data transformations, and solving systems of equations.

Matrix multiplication is a core operation in linear algebra and is widely used in fields like data science, physics, and engineering. To multiply two matrices, you must first ensure that their dimensions are compatible. Specifically, if you have a matrix $$A$$ with dimensions $$m \times n$$ (**m** rows and **n** columns) and a matrix $$B$$ with dimensions $$n \times p$$ (**n** rows and **p** columns), you can multiply them because the number of columns in $$A$$ matches the number of rows in $$B$$. The resulting matrix $$C$$ will have dimensions $$m \times p$$.

The element in the **i-th row** and **j-th column** of the product matrix is calculated by taking the **dot product** of the i-th row of matrix $$A$$ and the j-th column of matrix $$B$$. This means you multiply corresponding elements and sum the products. Mathematically, for each element $$C_{ij}$$, you compute:

$$
C_{ij} = A_{i0} * B_{0j} + A_{i1} * B_{1j} + ... + A_{i\ n-1} * B_{n-1\ j}
$$

This operation is **not commutative**: in general, $$A * B$$ is not equal to $$B * A$$. Matrix multiplication is used to represent linear transformations, combine data, and solve systems of equations, among many other applications.

import numpy as np

A = np.array([
    [1, 2, 3],
    [4, 5, 6]
])

B = np.array([
    [7, 8],
    [9, 10],
    [11, 12]
])

product = A @ B
print(product)

You can simplify matrix multiplication in Python using the `numpy` library and the `@` operator. The `@` operator performs matrix multiplication directly between two `numpy` arrays. When you use this operator, `numpy` automatically checks that the dimensions are compatible and performs the computation efficiently behind the scenes. This approach eliminates the need for explicit nested loops, making your code much simpler and easier to read. For example, if `A` and `B` are `numpy` arrays of compatible shapes, `A @ B` gives you the matrix product. This is the recommended way to perform matrix multiplication in modern Python code when working with numerical data.

import unittest
import numpy as np
import ast
import re
import io
import sys
import importlib

class TestTask(unittest.TestCase):
    
    def test_matrix_C_calculated_correctly(self):
        import user_code
        importlib.reload(user_code)
        
        # Очікуваний результат множення матриць
        expected = np.array([[6, 16], [7, 18]])
        
        # Перевіряємо чи існує C і чи дорівнює воно очікуваному результату
        has_c = hasattr(user_code, 'C')
        is_correct = has_c and np.array_equal(user_code.C, expected)
        
        _dynamic_test(
            self,
            is_correct,
            "Matrix C is correctly calculated as the dot product of A and B.",
            "Matrix C does not contain the correct product of A and B. Check your multiplication.",
        )

    def test_dynamic_computation(self):
        # Перевіряємо, чи студент дійсно множить матриці, а не просто написав C = np.array([[6, 16], [7, 18]])
        code = ''
        with open('user_code.py', 'r') as f:
            code = f.read()
            
        # Підміняємо значення A та B на нові
        code = change_var(code, 'A', 'np.array([[1, 0], [0, 1]])')
        code = change_var(code, 'B', 'np.array([[9, 9], [9, 9]])')
        
        ns = {'np': np}
        try:
            exec(code, ns)
            expected = np.array([[9, 9], [9, 9]])
            found = 'C' in ns and np.array_equal(ns['C'], expected)
        except Exception:
            found = False

        _dynamic_test(
            self,
            found,
            "Matrix multiplication is performed dynamically.",
            "It looks like the result for C is hardcoded. Use the multiplication operator (like @ or np.dot).",
        )

    def test_printed_output(self):
        # Перевіряємо, чи вивів студент матрицю C на екран
        f = io.StringIO()
        sys_stdout = sys.stdout
        sys.stdout = f
        try:
            import user_code
            importlib.reload(user_code)
        finally:
            sys.stdout = sys_stdout
            
        output = f.getvalue()
        
        # Шукаємо ключові числа з правильної матриці у виводі
        found = '6' in output and '16' in output and '7' in output and '18' in output
        
        _dynamic_test(
            self,
            found,
            "The result matrix C is printed successfully.",
            "The matrix C was not printed. Make sure to use print(C).",
        )


def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\s{2,}", " ", text)
    text = re.sub(r"\s*([,:?])\s*", r"\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]
    if not assign_nodes:
        return code
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True
    return '\\n'.join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()

test_main.py

Establish core mathematical intuition for data science by manipulating vectors, multiplying matrices, solving linear systems, and computing eigenvalues for dimensionality reduction, all utilizing Python.

All core linear algebra concepts for data science in one section, with each chapter building on the previous to develop a strong mathematical foundation using Python.

Matrix Multiplication

Ratkaisu