DEV Community: Ganesh Kumar

Understanding Idea behind Full Backpropogation

Ganesh Kumar — Wed, 17 Jun 2026 12:59:48 +0000

Hello, I'm Ganesh. I'm building git-lrc, an AI code reviewer that runs on every commit. It is free, unlimited, and source-available on Github. Star git-lrc on GitHub to help more developers discover the project. Do give it a try and share your feedback for improving the product.

In the previous article, we learned how to calculate the gradient of the last bias in a neural network.

Now we will explore how gradients flow through the entire network and how to calculate the weights of previous layers.

How to calculate weights

Now we will calculate weights of the previous layer

The challenge is that the loss function does not directly depend on these earlier weights.

For example, consider a weight (w1 and w2 are already calculated ) in a hidden layer.

Changing (w3 and w4):

Changes the hidden neuron output.
Changes the output neuron input.
Changes the final prediction.
Changes the loss.

So there is an indirect relationship between the weight and the loss.

This is exactly why we need the chain rule.

Conclusion

Similar to previous calculation we should also calculate for all weights and biases using chain rule and gradient descent.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.

⭐ Star git-lrc on GitHub

Why Do Neural Networks Need the Chain Rule? How do we apply it?

Ganesh Kumar — Sat, 13 Jun 2026 03:26:39 +0000

In the previous article, we introduced backpropagation and learned that neural networks improve by reducing prediction errors.

We also saw that backpropagation relies on two fundamental ideas:

The Chain Rule
Gradient Descent

But we haven't yet answered an important question:

How does we calculate wieghts and biases to decrease the error?

To answer that, let's look at a very small neural network.

A Simple Neural Network

Imagine a neural network with:
Similar to the previous example.

One input neuron
Two hidden neurons
One output neuron

Calculating Last Bias In the last layer

Let's asssume we have wieght and bias of all hidden layer and we only want to find last bias b3

Now from gradient descent, we can update the last bias b3 using the partial derivative of loss with respect to b3

The Error rate is done with Residuals.
Residual = Observed - Predicted

SSR = Sum of (Observed - Predicted)^2

So, We take 3 samples for training

Starting, Ending and middle values.

Finaly By calculating SSR.

Use of Chain Rule

We actually calculated b3 only using gradient descent.

Now Using chain Value generated from the weight and bias of previous layers

Predicted = Top Layer + Bottom Layer + Bias (b3)

Using Chain Rule we can write Dirivative of SSR with

dssr/db3 = dssr/dpredicted * dpredicted/db3

dssr/dpredicted = (Observed - Predicted)^2

As predicted, it is not constant and we are dirving it.

dssr/dpredicted = 2*(Observed - Predicted)*(d(Observed - Predicted))/dpredicted)

dssr/dpredicted = 2*(Observed - Predicted)(-1)
dssr/dpredicted = -2(Observed - Predicted)

For dpredicted/db3

dpredicted = Top Layer + Bottom Layer + Bias (b3)
Both Top Layer and Bottom Layer is constant for this calculation
dpredicted/db3 = 1

Finaly dssr/db3 = -2*(Observed - Predicted) * 1

Slop Calculation and Learning

Now we have 3 values of predicted for 3 samples

dssr/db3 = Σ(-2*(Observed-Predicted))

dssr/db3 = -2 * [(Observed1 - Predicted1) * 1 + (Observed2 - Predicted2) * 1 + (Observed3 - Predicted3) * 1]

dssr/db3 = -2 * [(Residual1) + (Residual2) + (Residual3)]

dssr/db3 = -2 * (ResidualSum)

For our training data I got slope = -15.7

step size = slope x learning rate

step size = -15.7 x 0.1 = -1.57

new b3 = old b3 + step size

new b3 = 0 + (-1.57) = -1.57

Then again, recalculating SSR with new b3 we got slop.

slop = -6.26

step size = -6.26 x 0.1 = -0.626

new b3 = -1.57 + (-0.626) = -2.196

Similarly after calculatinng multiple times utile we get step size close to 0.

Final Result
We found the optimal
b3 = 2.21

Conclusion

We could able to apply these chain rule, gradient descent and backpropagation in a very small neural network.

In next article we will discuss how to calculate wieghts and biases in same neural network.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.

⭐ Star git-lrc on GitHub

Running OpenAPI Validation in GitHub Actions and Showing Findings in Pull Requests

Ganesh Kumar — Wed, 10 Jun 2026 20:39:09 +0000

In a previous article, I explained what SARIF is and why many security and quality tools use it as a common reporting format.

In this article, we'll focus on a practical example: validating an OpenAPI specification in GitHub Actions and displaying findings directly inside GitHub Pull Requests.

By the end, you'll have a workflow that:

Lints your OpenAPI specification
Generates a SARIF report
Uploads results to GitHub Code Scanning
Shows annotations directly in Pull Requests

Sample OpenAPI Specification

Let's start with a simple OpenAPI file that contains a deliberate issue.

openapi: 3.0.3

info:
  title: User API
  version: 1.0.0

paths:
  /users/{id}:
    get:
      operationId: getUserById

      parameters:
        - name: userId
          in: path
          required: true
          schema:
            type: string

      responses:
        "200":
          description: User found

Notice that the path is:

/users/{id}

but the parameter is named:

userId

The parameter name should match the path placeholder (id).

We'll use this mistake to verify that our workflow correctly reports findings.

Installing Spectral

For this example, we'll use Spectral, one of the most popular OpenAPI linting tools.

npm install -g @stoplight/spectral-cli

Run it locally:

spectral lint openapi.yaml

You should see an error related to the path parameter mismatch.

Generating a SARIF Report

Instead of printing results to the console, we can generate a SARIF report:

spectral lint openapi.yaml \
  --format sarif \
  --output results.sarif

This produces:

results.sarif

which GitHub can consume directly.

GitHub Actions Workflow

Create:

.github/workflows/openapi.yml

name: OpenAPI Validation

on:
  pull_request:

permissions:
  contents: read
  security-events: write

jobs:
  openapi:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - uses: actions/setup-node@v4
        with:
          node-version: 20

      - name: Install Spectral
        run: npm install -g @stoplight/spectral-cli

      - name: Generate SARIF Report
        run: |
          spectral lint openapi.yaml \
            --format sarif \
            --output results.sarif

      - name: Upload SARIF
        uses: github/codeql-action/upload-sarif@v3
        with:
          sarif_file: results.sarif

How It Works

The workflow performs four simple steps:

Checks out the repository
Installs Spectral
Generates a SARIF report
Uploads the SARIF report to GitHub

The upload step is handled by GitHub's official SARIF uploader:

- uses: github/codeql-action/upload-sarif@v3
  with:
    sarif_file: results.sarif

Once uploaded, GitHub automatically processes the findings.

Viewing Results in Pull Requests

After opening a Pull Request, GitHub analyzes the uploaded SARIF report and associates findings with the corresponding files and lines.

For our example, GitHub highlights the parameter definition and reports something similar to:

Path parameter "id" is not defined.
Expected parameter name "id" but found "userId".

Developers can review the issue directly from the Pull Request without searching through GitHub Action logs.

Why I Prefer This Approach

Many teams fail OpenAPI validation jobs and require developers to inspect CI logs.

While this works, it doesn't scale well when repositories contain multiple specifications or many validation rules.

Uploading SARIF results provides:

Inline annotations
Better visibility during code review
Centralized findings in GitHub Code Scanning
Consistent reporting across different tools

The same workflow can later be extended to include security scanners, secret scanners, IaC scanners, and custom validation tools.

Conclusion

Integrating OpenAPI validation into GitHub Actions is straightforward. With Spectral generating SARIF output and GitHub handling the presentation layer, developers receive feedback exactly where they are already reviewing code: inside the Pull Request.

If your organization already uses SARIF for other security or quality tools, OpenAPI validation can fit naturally into the same workflow with only a few lines of configuration.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.

⭐ Star git-lrc on GitHub

What Is SARIF and How Does It Help Security Tools Work Together?

Ganesh Kumar — Mon, 08 Jun 2026 20:28:21 +0000

If you've ever worked with tools like Semgrep, Trivy, Checkov, Gitleaks, or CodeQL, you've probably noticed that each tool produces results in a different format. Some output JSON, some use XML, while others generate plain text reports.

This creates a problem: how do you aggregate multiple tools results from multiple tools into a single platform?

That's where SARIF comes in.

What is SARIF?

SARIF stands for Static Analysis Results Interchange Format.

It is an open standard designed to represent findings from static analysis tools, security scanners, linters, and code quality tools in a common format.

Think of SARIF as a universal translator.

Instead of every tool speaking its own language:

Semgrep -> Semgrep JSON
Trivy -> Trivy JSON
Checkov -> Checkov JSON
Gitleaks -> Gitleaks JSON

SARIF allows all of them to communicate using a shared structure:

Semgrep
Trivy
Checkov
Gitleaks
    ↓
   SARIF

Why Was SARIF Created?

Imagine a company running 20 different scanners in its CI/CD pipeline.

Each scanner reports:

Different severity levels
Different file formats
Different metadata
Different output structures
Different CVE
Different CVSS scores

Building integrations for every tool becomes difficult and expensive.

SARIF solves this problem by providing a standardized schema for:

Rule IDs
Messages
Severity
File locations
Code snippets
Security metadata
Fix suggestions

This allows platforms to consume results from many tools without writing custom integrations for each one.

A Simple Example

Suppose a security scanner finds a vulnerability:

File: app.py
Line: 42
Severity: High
Message: Possible SQL Injection

In SARIF, that information becomes structured JSON that any compatible platform can understand.

The scanner changes, but the format remains the same.

How SARIF Helps Developers

One Format for Many Tools

Instead of handling dozens of output formats:

Tool A -> Format A
Tool B -> Format B
Tool C -> Format C

you can standardize on:

Tool A
Tool B
Tool C
   ↓
 SARIF

Better Tool Interoperability

A SARIF file generated by one tool can be consumed by another platform without modification.

This makes integrations significantly easier.

GitHub Code Scanning Support

One of the biggest reasons SARIF became popular is GitHub Code Scanning.

GitHub accepts SARIF uploads and automatically displays:

Security findings
Code quality issues
Vulnerabilities
File-level annotations

directly inside pull requests and repositories.

Easier Aggregation

Organizations often run multiple scanners:

Semgrep
Trivy
Checkov
Gitleaks
Bandit

SARIF makes it possible to combine all findings into a single report.

Conclusion

SARIF is a common language that allows tools to exchange findings in a standard way.

As the number of security and code analysis tools continues to grow, standards like SARIF help reduce integration complexity and make tool ecosystems work together more effectively.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.

⭐ Star git-lrc on GitHub

Understanding Backpropagation: How Neural Networks Learn from Their Mistakes

Ganesh Kumar — Sat, 06 Jun 2026 19:46:43 +0000

From Linear Regression to Gradient Descent

In previous parts we discussed about linear regression, gradient descent and how to calculate the optimal slope and intercept using Gradient Descent.

In this article, we'll build an intuition for backpropagation, understand why it is necessary, and explore how the chain rule and gradient descent work together to enable neural network learning.

What is Backpropagation?

Backpropagation is an algorithm used to train neural networks.

It is a way to adjust the weights and biases of a neural network to reduce the error between the predicted output and the actual output.

In simple terms, it is a way for the neural network to learn from its mistakes.

This learning process is powered by an algorithm called backpropagation, one of the most important concepts in machine learning. Backpropagation provides a systematic way for a neural network to determine which internal parameters contributed to an error and how those parameters should be updated to reduce future mistakes.

Imagine teaching a student to solve math problems.

After each attempt, you compare the student's answer with the correct one, identify where mistakes occurred, and provide feedback. Over time, the student adjusts their approach and improves. Backpropagation works in a similar way: the network makes a prediction, calculates the error, traces that error backward through the network, and updates its parameters accordingly.

At its core, backpropagation combines two fundamental mathematical ideas:

The Chain Rule from calculus, which helps determine how changes in one part of the network affect the final error.
Gradient Descent, an optimization technique that uses those calculations to update the network's parameters in the direction that reduces error.

By repeatedly answering these questions across thousands or millions of training examples, neural networks gradually learn patterns hidden within data and become increasingly accurate.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.

⭐ Star git-lrc on GitHub

Why can't we just use one storage technology for everything?

Ganesh Kumar — Thu, 04 Jun 2026 19:41:14 +0000

Modern computers use multiple storage and memory technologies because no single medium can simultaneously provide massive capacity, ultra-low latency, high bandwidth, and low cost.

Every level of the memory hierarchy represents a tradeoff between these characteristics.

Why is there a memory hierarchy?

This is because each storage technology has its own advantages and disadvantages. We can't use one storage technology for all the purposes.

The main characteristics to consider are:

Capacity
Latency
Bandwidth
Cost

Each Storage technology is optimized for a specific purpose.

For example:
Imagine you have to travel from one place to another.
You can go with walking, bicycle, car, train, or plane.

Each mode of transport has its own advantages and disadvantages.

Another better example is think of using LLM model.

Depending on task complexity and size of data we can choose the model.

If we mess up with choosing model we will not get the desired output wheather cost will rise, or response will be very low quality.

Memory Hierarchy

Now I have listed down the memory hierarchy From top to bottom.

CPU Registers

This is the fastest storage available inside a processor.

Role:
Stores values currently being operated on by the CPU.

Characteristic	Value
Capacity	Extremely small (typically 32 × 64-bit registers per core)
Latency	~0.3 ns (about one CPU cycle)
Bandwidth	Highest in the system
Cost	Highest cost per bit (16 transistors per bit)

CPU Cache (L1, L2, L3)

A small, ultra-fast memory layer designed to keep frequently used data close to the processor.

Role: Reduces the need to access slower main memory.

Characteristic	Value
Capacity	Small (tens of MB total)
Latency	~7.5 ns (L3 cache)
Bandwidth	Extremely high
Cost	Very expensive (SRAM, 6 transistors per bit)

DRAM (Main Memory)

The working memory used by applications and operating systems.

Role: Holds active programs and data currently being used.

Characteristic	Value
Capacity	Typically 32 GB
Latency	~45 ns
Bandwidth	~48 GB/s
Cost	Higher than storage drives

GPU VRAM

Memory optimized for throughput rather than low latency.
Role: Feeds large amounts of data to thousands of GPU cores simultaneously.

Characteristic	Value
Capacity	~24 GB
Latency	~250 ns
Bandwidth	Extremely high
Cost	Expensive

NVMe SSD

High-speed solid-state storage connected through PCIe.
Role: Fast persistent storage for operating systems, applications, and files.

Characteristic	Value
Capacity	~2 TB
Read Latency	~80 μs
Write Latency	~500 μs
Bandwidth	~5 GB/s
Cost	~7 cents per GB

SATA SSD

An older solid-state storage technology using the SATA interface.

Role: Affordable solid-state storage with lower performance than NVMe.

Characteristic	Value
Capacity	Up to ~4 TB
Latency	~120 μs
Bandwidth	Lower than NVMe
Cost	Similar to NVMe SSDs

Hard Disk Drive (HDD)

Mechanical storage using spinning magnetic platters.
Role: Lowest-cost local storage for large datasets and archives.

Characteristic	Value
Capacity	~8 TB
Latency	~8.3–10 ms
Bandwidth	Very low compared to SSDs
Cost	~1–2 cents per GB

The Fundamental Tradeoff

As we move down the memory hierarchy:

Capacity increases.
Cost per GB decreases.
Latency increases.
Access speed decreases.
Distance from the processor increases.

By leveraging this trade-off, modern computers use a hierarchy of registers, cache, memory, SSDs, HDDs, and cloud storage instead of relying on a single storage technology.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.

⭐ Star git-lrc on GitHub

Credits

Here are the sources that inspired me to write an article on this topic.

Why Don’t Computers Just Use One Type of Memory?

From Linear Regression to Gradient Descent

Ganesh Kumar — Thu, 04 Jun 2026 06:14:59 +0000

In the previous section, we learned that linear regression finds the best-fitting line by determining the optimal slope and intercept.

In this article, we will discuss how to calculate the optimal slope and intercept using Gradient Descent.

How to calculate the optimal slope and intercept using Gradient Descent

The quality of that line is measured using the Sum of Squared Residuals (SSR), which represents the total prediction error.

SSR = sum( (y_observed - y_predicted)^2 )

The best regression line is simply the line that produces the smallest SSR.

When studying linear regression, it's easy to think that the slope and intercept magically appear from a formula. In reality, they are the values that minimize the prediction error. This is where Gradient Descent comes in.

Instead of calculating the optimal slope and intercept directly using a closed-form equation, Gradient Descent starts with arbitrary values and gradually improves them. After each step, it measures how the SSR changes and adjusts the parameters in the direction that reduces the error.

Step-by-Step Gradient Descent Example

Let's illustrate how Gradient Descent works using the exact same dataset of 4 points from Part 10:

1. The Dataset

Point 1: (1, 2)
Point 2: (2, 3)
Point 3: (3, 5)
Point 4: (4, 4)

2. Simplifying the Problem

To make the math easy to trace, we will hold the Slope (m) constant at its optimal value of 0.8 and focus purely on finding the optimal Intercept (b).

Our prediction equation is:

y_predicted = 0.8 * x + b

We start with an initial guess for the intercept: b = 0.

3. Calculating the Initial SSR (at b = 0)

Let's find the predicted values and calculate the residuals (observed - predicted):

For Point 1 (1, 2):
- y_predicted = 0.8 * 1 + 0 = 0.8
- Residual_1 = 2 - 0.8 = 1.2
For Point 2 (2, 3):
- y_predicted = 0.8 * 2 + 0 = 1.6
- Residual_2 = 3 - 1.6 = 1.4
For Point 3 (3, 5):
- y_predicted = 0.8 * 3 + 0 = 2.4
- Residual_3 = 5 - 2.4 = 2.6
For Point 4 (4, 4):
- y_predicted = 0.8 * 4 + 0 = 3.2
- Residual_4 = 4 - 3.2 = 0.8

Now, sum the squared residuals:

SSR = 1.2^2 + 1.4^2 + 2.6^2 + 0.8^2
    = 1.44 + 1.96 + 6.76 + 0.64
    = 10.8

4. Derivation of the Gradient (d(SSR)/db)

To know which direction to move the intercept b and by how much, we take the derivative of SSR with respect to b:

SSR = sum( (y_observed - (0.8 * x_observed + b))^2 )

Applying the chain rule:

d(SSR)/db = sum( 2 * (y_observed - (0.8 * x_observed + b)) * (-1) )
          = -2 * sum( y_observed - y_predicted )
          = -2 * sum( Residuals )

The gradient is simply -2 times the sum of the residuals.

5. Updating the Intercept

The update rule is:

b_new = b_old - (Learning Rate * Gradient)

Let's choose a Learning Rate (LR) of 0.1.

Step 1:
- Gradient: d(SSR)/db = -2 * (1.2 + 1.4 + 2.6 + 0.8) = -2 * 6.0 = -12.0
- Step Size: Gradient * LR = -12.0 * 0.1 = -1.2
- New Intercept: b_new = 0 - (-1.2) = 1.2
Step 2:
- With b = 1.2, the predictions are closer to the actual values.
- The new residuals are: 0.0, 0.2, 1.4, and -0.4.
- SSR: 0.0^2 + 0.2^2 + 1.4^2 + (-0.4)^2 = 2.16
- Gradient: -2 * (0.0 + 0.2 + 1.4 - 0.4) = -2.4
- Step Size: -2.4 * 0.1 = -0.24
- New Intercept: b_new = 1.2 - (-0.24) = 1.44
Step 3 (Convergence):
- With b = 1.44, the new residuals are: -0.24, -0.04, 1.16, and -0.64.
- Gradient: -2 * (-0.24 - 0.04 + 1.16 - 0.64) = -0.48
- Step Size: -0.48 * 0.1 = -0.048
- New Intercept: b_new = 1.44 - (-0.048) = 1.488
- We repeat this loop. As we approach the optimal intercept, the residuals sum up closer to 0, which shrinks the gradient and steps.
- After several iterations, the gradient becomes 0, and the intercept converges to the exact optimal value of 1.5 (where SSR reaches its minimum value of 1.8).

Conclusion

We started with an arbitrary intercept of 0 and adjusted it step-by-step. Each step was guided by the gradient, which told us exactly how much to change the intercept to reduce the prediction error (SSR). We repeated this process until the error reached its minimum.

While this example focused on a simple linear regression with a single variable, this same principle applies to deep neural networks with millions of parameters. Gradient descent is the engine that drives learning in machine learning.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.

⭐ Star git-lrc on GitHub

Mathematical Intuition of Linear Regression

Ganesh Kumar — Tue, 02 Jun 2026 18:19:25 +0000

Linear Regression Line

The line is drawn between two axes, X and Y.

We can draw infinite lines with different points. But only one will be best fit for the given points.

For a set of 2D points (x_i,y_i), the simplest linear regression model is:

y = mx + b

Where:

(m) = slope
(b) = intercept

To compute them from your points:

Slope:

m = (n∑xy−(∑x)(∑y)) / (n∑x^2−(∑x)^2)

Intercept:

b = (∑y−m∑x) / n

Then your best-fit line is:

y = mx + b

Calculation of Slope

For example points:

x	y
1	2
2	3
3	5
4	4

Result:
m = 0.8
b = 1.5

Best-fit line:
y = 0.8x + 1.5

Finally we get the result:

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.

⭐ Star git-lrc on GitHub

Main Idea of Least Squares Method and Linear Regression

Ganesh Kumar — Sun, 31 May 2026 18:41:12 +0000

Linear Regression is a method that finds the best fitting line for a set of data points.

It is used to predict the value of a dependent variable based on the value of one or more independent variables.

let's assume we have a set of data points $(x_1, y_1), (x_2, y_2), ..., (x_n, y_n)$.

The data points can be represented as a scatter plot.

The data points are scattered in a way that it may represent a line.

where each point $(x_i, y_i)$ represents a data point.

A line can be represented as $y = mx + b$, where $m$ is the slope and $b$ is the y-intercept.

Usually, we have some random value of $m$ and $b$ and we want to find the best value of $m$ and $b$ such that the line passes through the data points.

For example in this graph there are mulitple data points, and we want to find the best fitting line for these data points.

This can be done using the least squares method.

Least Squares Method

The least squares method is a method that finds the best fitting line for a set of data points.

we calculate the sum of the squares of the differences between the actual values and the predicted values.

$(y_i - (mx_i + b))^2$

We want to minimize this value.

So, we check each state of line and calculate the sum of the squares of the differences between the actual values and the predicted values.

We choose the line that minimizes this value.

How this is done mathematically

This whole caculation can be done mathematically. I will discuss in depth in my next article.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.

⭐ Star git-lrc on GitHub

The Beautiful Cube Series Identity That Looks Like Coincidence

Ganesh Kumar — Fri, 29 May 2026 18:37:55 +0000

A Math Identity That Feels Wrong

While playing with number series, I came across something that looked like a coincidence.
Let's start with:

√(1³ + 2³)
= √(1 + 8)
= √9
= 3

Nothing special yet.

But notice:

3 = 1 + 2

Interesting.

Let's add another cube.

√(1³ + 2³ + 3³)
= √(1 + 8 + 27)
= √36
= 6

And:

6 = 1 + 2 + 3

Now it starts looking suspicious.

Let's continue.

√(1³ + 2³ + 3³ + 4³)
= √100
= 10

And:

10 = 1 + 2 + 3 + 4

One more:

√(1³ + 2³ + 3³ + 4³ + 5³)
= √225
= 15

Which is exactly:

15 = 1 + 2 + 3 + 4 + 5

At this point most people assume it only works for small numbers.

Surprisingly, it works for every positive integer.

The Identity

The pattern can be written as:

√(1³ + 2³ + 3³ + ... + n³)
= 1 + 2 + 3 + ... + n

Or equivalently:

1³ + 2³ + 3³ + ... + n³
=
(1 + 2 + 3 + ... + n)²

This means the sum of the first n cubes is exactly equal to the square of the sum of the first n natural numbers.

Many people see this formula for the first time and immediately think:

There is no way that should be true.

Yet it is.

Testing With n = 10

Let's verify it.

Left side:

1³ + 2³ + 3³ + ... + 10³
= 3025

Right side:

(1 + 2 + 3 + ... + 10)²

= 55²

= 3025

Perfect match.

Why Mathematicians Love It

Most formulas involving powers become increasingly complicated.

For example:

1² + 2² + ... + n²

requires a special formula.

1⁴ + 2⁴ + ... + n⁴

requires an even more complicated formula.

But cubes are special.

They collapse into a perfect square:

1³ + 2³ + ... + n³
=
(1 + 2 + ... + n)²

It is one of the most elegant identities in elementary mathematics.

The Closed Form

Since:

1 + 2 + 3 + ... + n
=
n(n + 1)/2

we can rewrite the cube identity as:

1³ + 2³ + 3³ + ... + n³
=
[n(n + 1)/2]²

This is commonly known as the Sum of Cubes Formula.

It is also associated with Nicomachus's Theorem, a result known for nearly two thousand years.

Final Thoughts

Mathematics is full of formulas, but only a few make you stop and check your calculator twice.

The cube series identity is one of them:

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.

⭐ Star git-lrc on GitHub

Slope Intercept Form with Gradient Descent

Ganesh Kumar — Sun, 24 May 2026 18:46:14 +0000

Slope-Intercept Form equation

A residual is the difference between the actual y value and the predicted y value.

Residule = (Actual Y - Predicted Y)

Finally, the residual is squared, and the sum of all the residuals is calculated, which is called the Mean Squared Error (MSE).

(Residual)^2 is nothing but the vertical distance between the predicted line and the actual data points, squared.

The lesser the value, the greater the accuracy.

Using this Mean Squared Error (MSE), we can adjust the slope and y-intercept to minimize the error.

Conclusion

Will discuss Gradient Descent in the next part.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.

⭐ Star git-lrc on GitHub
Slope Intercept Form with Gradient Descent

Slope-Intercept Form equation

Ganesh Kumar — Fri, 22 May 2026 13:00:13 +0000

In above image we got Y = Intercept + (Slope x X)

Also writen as
y = mx + b

where
y = Intercept + (Slop x X)
y = output / dependent variable
x = input / independent variable
m = slope (rate of change)
b = y-intercept (starting value)

Why is this formula used?

This formula is used to represent a linear relationship, meaning something changes at a constant rate.

It helps answer.

Where does the line start?
How fast does it increase or decrease?

Basically making it more like how the graph is drawn in math.

Using this equation, we can get the y value for a given x value.

How It is used in Neural Networks

The above linear equation is the Core building block of a neuron but with many inputs.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.

⭐ Star git-lrc on GitHub