Gunakasamuchya — Sutras for Verification of Calculations

In this tutorial, you'll learn about Gunakasamuchya. We cover key concepts, practical examples, and best practices.

Gunakasamuchya ("The product of the sum is the sum of the product") verifies arithmetic calculations using the digital root — if the digital root of a product matches the product of the digital roots, the answer is likely correct.

The Sutra: Product of the Sum

Gunakasamuchya states: "The product of the sums equals the sum of the products." More practically: the digital root of the result must equal the digital root of the operation performed on the digital roots of the inputs.

Digital root: Sum the digits of a number repeatedly until a single digit (1-9) remains. For example, 345 -> 3+4+5 = 12 -> 1+2 = 3.

For multiplication: digital_root(a x b) must equal digital_root(digital_root(a) x digital_root(b)).

Verification Flow

flowchart TD
    A["Calculate result
345 × 678 = 233910"] --> B["Find digital root
of each input"]
    B --> C["DR(345) = 3
DR(678) = 3"]
    C --> D["Multiply digital roots
3 × 3 = 9"]
    D --> E["DR(9) = 9"]
    A --> F["Find digital root
of result"]
    F --> G["DR(233910) = 9"]
    E --> H{Match?}
    G --> H
    H -->|Yes| I["Answer likely correct"]
    H -->|No| J["Answer is WRONG"]

    style A fill:#1a73e8,color:#fff,stroke:none
    style C fill:#34a853,color:#fff,stroke:none
    style H fill:#fbbc04,color:#333,stroke:none
    style I fill:#34a853,color:#fff,stroke:none
    style J fill:#ea4335,color:#fff,stroke:none

Worked Examples

Example 1: Verifying multiplication

Check if 345 x 678 = 233910.

Step 1: Find digital root of 345: 3 + 4 + 5 = 12, 1 + 2 = 3.

Step 2: Find digital root of 678: 6 + 7 + 8 = 21, 2 + 1 = 3.

Step 3: Multiply digital roots: 3 x 3 = 9. Digital root of 9 = 9.

Step 4: Find digital root of result 233910: 2 + 3 + 3 + 9 + 1 + 0 = 18, 1 + 8 = 9.

Step 5: Compare: 9 = 9. The verification passes.

Conclusion: 233910 is likely correct.

Check: 345 x 678 = 233910.

Example 2: Catching an error

Check if 456 x 789 = 359784 (this is wrong).

Step 1: DR(456) = 4 + 5 + 6 = 15, 1 + 5 = 6.

Step 2: DR(789) = 7 + 8 + 9 = 24, 2 + 4 = 6.

Step 3: DR(6 x 6) = DR(36) = 3 + 6 = 9.

Step 4: DR(359784) = 3 + 5 + 9 + 7 + 8 + 4 = 36, 3 + 6 = 9.

Wait — this also matches! The error slipped through. Let me try a different wrong answer.

Check if 456 x 789 = 359685.

Step 1: DR(456) = 6, DR(789) = 6. Product DR = 9.

Step 2: DR(359685) = 3 + 5 + 9 + 6 + 8 + 5 = 36, 3 + 6 = 9.

This also matches! Digital root verification catches most errors but not all. Let me try a clearly wrong answer:

456 x 789 = 360000 (obviously wrong).

Step 1: DR(456) = 6, DR(789) = 6. Expected DR = 9.

Step 2: DR(360000) = 3 + 6 = 9.

Still matches. The method catches about 90% of errors but has a 10% false-pass rate. For better accuracy, combine with digit-sum mod 9 and cast out nines.

Let me try a different error: 456 x 789 = 359788.

Step 1: DR(359788) = 3 + 5 + 9 + 7 + 8 + 8 = 40, 4 + 0 = 4.

Step 2: Expected DR = 9, Got DR = 4. Mismatch!

Conclusion: 359788 is definitely wrong.

The actual answer: 456 x 789 = 359784.

Example 3: Verifying addition

Check if 1234 + 5678 = 6912.

Step 1: DR(1234) = 1 + 2 + 3 + 4 = 10, 1 + 0 = 1.

Step 2: DR(5678) = 5 + 6 + 7 + 8 = 26, 2 + 6 = 8.

Step 3: Sum of digital roots: 1 + 8 = 9. DR(9) = 9.

Step 4: DR(6912) = 6 + 9 + 1 + 2 = 18, 1 + 8 = 9.

Step 5: 9 = 9. Passes verification.

Check: 1234 + 5678 = 6912.

Example 4: Verifying division

Check if 8456 / 7 = 1208.

Step 1: For division, verify using multiplication: divisor x quotient + remainder = dividend.

Step 2: DR(7) = 7. DR(1208) = 1 + 2 + 0 + 8 = 11, 1 + 1 = 2.

Step 3: DR(7 x 1208) = DR(DR(7) x DR(1208)) = DR(7 x 2) = DR(14) = 1 + 4 = 5.

Step 4: DR(8456) = 8 + 4 + 5 + 6 = 23, 2 + 3 = 5.

Step 5: 5 = 5. Verification passes.

Check: 7 x 1208 = 8456.

Example 5: Casting out nines

This is the same principle but using modulo 9 directly. Instead of computing digital roots, divide each number by 9 and use the remainder.

Check 385 x 492 = 189420.

Step 1: 385 mod 9 = 385 - 9 x 42 = 385 - 378 = 7.

Step 2: 492 mod 9 = 492 - 9 x 54 = 492 - 486 = 6.

Step 3: 7 x 6 = 42 mod 9 = 6.

Step 4: 189420 mod 9 = 189420 - 9 x 21046 = 189420 - 189414 = 6.

Step 5: 6 = 6. Passes.

(If a remainder is 0, the digital root is 9.)

Code Snippet: Python Implementation

def digital_root(n):
    """Compute digital root of a number."""
    if n == 0:
        return 0
    return 1 + ((n - 1) % 9)


def verify_multiplication(a, b, result, verbose=True):
    """Verify a x b = result using Gunakasamuchya."""
    dr_a = digital_root(a)
    dr_b = digital_root(b)
    dr_product = digital_root(dr_a * dr_b)
    dr_result = digital_root(result)

    if verbose:
        print(f"Verifying: {a} x {b} = {result}")
        print(f"  DR({a}) = {dr_a}")
        print(f"  DR({b}) = {dr_b}")
        print(f"  DR({dr_a} x {dr_b}) = {dr_product}")
        print(f"  DR({result}) = {dr_result}")

    if dr_product == dr_result:
        if verbose:
            print(f"  {dr_product} = {dr_result} → PASS")
        return True
    else:
        if verbose:
            print(f"  {dr_product} != {dr_result} → FAIL")
        return False


def verify_addition(a, b, result, verbose=True):
    """Verify a + b = result using digital roots."""
    dr_a = digital_root(a)
    dr_b = digital_root(b)
    dr_sum = digital_root(dr_a + dr_b)
    dr_result = digital_root(result)

    if verbose:
        print(f"Verifying: {a} + {b} = {result}")
        print(f"  DR sum = {dr_sum}, DR result = {dr_result}")

    return dr_sum == dr_result


# Test cases
tests_mul = [
    (345, 678, 233910), "# correct
    (456", 789, 359788), "# wrong
    (456", 789, 359784), "# correct
    (385", 492, 189420),   # correct
]

for a, b, res in tests_mul:
    result = verify_multiplication(a, b, res)
    print(f"  {'✓' if result else '✗'} verification\n")

# Test a wrong addition
verify_addition(1234, 5678, 6913)  # should be 6912

Expected output:

Verifying: 345 x 678 = 233910
  DR(345) = 3
  DR(678) = 3
  DR(3 x 3) = 9
  DR(233910) = 9
  9 = 9 → PASS
  ✓ verification

Verifying: 456 x 789 = 359788
  DR(456) = 6
  DR(789) = 6
  DR(6 x 6) = 9
  DR(359788) = 4
  9 != 4 → FAIL
  ✗ verification

Verifying: 456 x 789 = 359784
  DR(456) = 6
  DR(789) = 6
  DR(6 x 6) = 9
  DR(359784) = 9
  9 = 9 → PASS
  ✓ verification

Verifying: 385 x 492 = 189420
  DR(385) = 7
  DR(492) = 6
  DR(7 x 6) = 6
  DR(189420) = 6
  6 = 6 → PASS
  ✓ verification

Verifying: 1234 + 5678 = 6913
  DR sum = 9, DR result = 1

Code Snippet: JavaScript Implementation

function digitalRoot(n) {
    if (n === 0) return 0;
    return 1 + ((n - 1) % 9);
}

function verifyMultiplication(a, b, result) {
    const drA = digitalRoot(a);
    const drB = digitalRoot(b);
    const drProd = digitalRoot(drA * drB);
    const drRes = digitalRoot(result);
    const pass = drProd === drRes;

    console.log(`${a} x ${b} = ${result}: ` +
        `DR(${a})=${drA}, DR(${b})=${drB}, ` +
        `expected=${drProd}, got=${drRes} ` +
        `${pass ? 'PASS' : 'FAIL'}`);
    return pass;
}

verifyMultiplication(345, 678, 233910);
verifyMultiplication(456, 789, 359788);
verifyMultiplication(1234, 5678, 6913);

Common Errors

1. Confusing digital root with sum of digits. The digital root reduces to a single digit by repeated summation. 345 -> 3+4+5 = 12 -> 1+2 = 3. The sum of digits (12) is not the digital root (3).

2. Treating zero as a digital root of 9. In digital root calculation, 0 is only the result for the number 0 itself. For any non-zero number divisible by 9, the digital root is 9, not 0.

3. Assuming a pass means the answer is definitely correct. Gunakasamuchya verification passes about 90% of wrong answers undetected. A pass means "probably correct" not "definitely correct." A fail means "definitely wrong."

4. Applying verification only to the final answer. Verify each intermediate step too. For multi-step problems, if step 1's answer fails verification, stop and correct before proceeding.

5. Forgetting to check the remainder in division verification. For division with remainder, the verification is: DR(divisor x quotient) + DR(remainder) should equal DR(dividend). Skipping the remainder gives false failures.

Practice Questions

1. Verify if 567 x 891 = 505197 using Gunakasamuchya.
2. Check if 2345 + 6789 = 9134.
3. Is 998 x 997 = 995006 correct? Verify with digital roots.

Answers:

1. DR(567)=9, DR(891)=9, DR(9x9)=9, DR(505197)=9, PASS. (Correct: 567x891=505197)
2. DR(2345)=5, DR(6789)=3, DR(5+3)=8, DR(9134)=8, PASS. (Correct: 2345+6789=9134)
3. DR(998)=8, DR(997)=7, DR(8x7)=DR(56)=2, DR(995006)=2, PASS. (Correct: 998x997=995006)

Mini Project: Verification Calculator

def gunakasamuchya_verify(operation, *args):
    """Universal verification using Gunakasamuchya."""
    if operation == 'add':
        a, b, result = args
        return verify_addition(a, b, result, verbose=False)
    elif operation == 'mul':
        a, b, result = args
        return verify_multiplication(a, b, result, verbose=False)
    elif operation == 'sub':
        a, b, result = args
        # a - b = result means a = result + b
        return verify_addition(result, b, a, verbose=False)
    elif operation == 'div':
        dividend, divisor, quotient, remainder = args
        # dividend = divisor * quotient + remainder
        prod = divisor * quotient + remainder
        return digital_root(dividend) == digital_root(prod)

# Batch check
checks = [
    ('mul', 567, 891, 505197),
    ('add', 2345, 6789, 9134),
    ('mul', 998, 997, 995006),
    ('mul', 123, 456, 56087),  # Wrong answer
]

for op, *vals in checks:
    passes = gunakasamuchya_verify(op, *vals)
    status = "PASS" if passes else "FAIL"
    print(f"{op} {vals}: {status}")

FAQ

Next Steps

Continue with Digital Roots for a deeper dive into digital root theory and applications.

Related tutorials:

• Checking Calculations — Vedic digital roots for verification
• Vedic Maths Overview — introduction to all Vedic sutras

Built by the developers of Doda Browser, DodaZIP, and Durga Antivirus Pro.