# Freivald’s Algorithm to check if a matrix is product of two

Given three matrices A, B and C, find if C is a product of A and B.
Examples:

```Input : A = 1 1
1 1
B = 1 1
1 1
C = 2  2
2 2
Output : Yes
C = A x B

Input : A = 1 1 1
1 1 1
1 1 1
B = 1 1 1
1 1 1
1 1 1
C = 3 3 3
3 1 2
3 3 3
Output : No```

A simple solution is to find product of A and B and then check if product is equal to C or not. A possible time complexity of this method is O(n2.8874) using Stression’s matrix multiplication

Freivalds’ algorithm is a probabilistic randomized algorithm that works in time O(n2) with high probability. In O(kn2) time the algorithm can verify a matrix product with probability of failure less than 2-k. Since the output is not always correct, it is a Monte Carlo randomized algorithm.

Steps :

1. Generate an n × 1 random 0/1 vector r?.
2. Compute P? = A × (Br)? – Cr?.
3. Return true if P? = ( 0, 0, …, 0 )T, return false otherwise.

The idea is based on the fact that if C is actually a product, then value of A × (Br)? – Cr? will always be 0. If the value is non-zero, then C can not be a product. The error condition is that the value may be 0 even when C is not a product.

Below is the implementation of the above approach:

## C++

 `// CPP code to implement Freivald’s Algorithm``#include ``using` `namespace` `std;` `#define N 2` `// Function to check if ABx = Cx``int` `freivald(``int` `a[][N], ``int` `b[][N], ``int` `c[][N])``{``    ``// Generate a random vector``    ``bool` `r[N];``    ``for` `(``int` `i = 0; i < N; i++)``        ``r[i] = random() % 2;` `    ``// Now compute B*r for evaluating``    ``// expression A * (B*r) - (C*r)``    ``int` `br[N] = { 0 };``    ``for` `(``int` `i = 0; i < N; i++)``        ``for` `(``int` `j = 0; j < N; j++)``            ``br[i] = br[i] + b[i][j] * r[j];` `    ``// Now compute C*r for evaluating``    ``// expression A * (B*r) - (C*r)``    ``int` `cr[N] = { 0 };``    ``for` `(``int` `i = 0; i < N; i++)``        ``for` `(``int` `j = 0; j < N; j++)``            ``cr[i] = cr[i] + c[i][j] * r[j];` `    ``// Now compute A* (B*r) for evaluating``    ``// expression A * (B*r) - (C*r)``    ``int` `axbr[N] = { 0 };``    ``for` `(``int` `i = 0; i < N; i++)``        ``for` `(``int` `j = 0; j < N; j++)``            ``axbr[i] = axbr[i] + a[i][j] * br[j];` `    ``// Finally check if value of expression``    ``// A * (B*r) - (C*r) is 0 or not``    ``for` `(``int` `i = 0; i < N; i++)``        ``if` `(axbr[i] - cr[i] != 0)``            ``false``;` `    ``return` `true``;``}` `// Runs k iterations Freivald. The value``// of k determines accuracy. Higher value``// means higher accuracy.``bool` `isProduct(``int` `a[][N], ``int` `b[][N],``               ``int` `c[][N], ``int` `k)``{``    ``for` `(``int` `i=0; i

## Java

 `// Java code to implement ``// Freivald's Algorithm``import` `java.io.*;``import` `java.util.*;``import` `java.math.*;` `class` `GFG {``    ``static` `int` `N = ``2``;` `    ``// Function to check if ABx = Cx``    ``static` `boolean` `freivald(``int` `a[][], ``int` `b[][],``                                       ``int` `c[][])``    ``{``        ``// Generate a random vector``        ``int` `r[] = ``new` `int``[N];``        ``for` `(``int` `i = ``0``; i < N; i++)``        ``r[i] = (``int``)(Math.random()) % ``2``;` `        ``// Now compute B*r for evaluating``        ``// expression A * (B*r) - (C*r)``        ``int` `br[] = ``new` `int``[N];``        ``Arrays.fill(br, ``0``);``        ``for` `(``int` `i = ``0``; i < N; i++)``            ``for` `(``int` `j = ``0``; j < N; j++)``                ``br[i] = br[i] + b[i][j] * r[j];` `        ``// Now compute C*r for evaluating``        ``// expression A * (B*r) - (C*r)``        ``int` `cr[] = ``new` `int``[N];``        ``Arrays.fill(cr, ``0``);``        ``for` `(``int` `i = ``0``; i < N; i++)``            ``for` `(``int` `j = ``0``; j < N; j++)``                ``cr[i] = cr[i] + c[i][j] * r[j];` `        ``// Now compute A* (B*r) for evaluating``        ``// expression A * (B*r) - (C*r)``        ``int` `axbr[] = ``new` `int``[N];``        ``Arrays.fill(axbr, ``0``);``        ``for` `(``int` `i = ``0``; i < N; i++)``            ``for` `(``int` `j = ``0``; j < N; j++)``                ``axbr[i] = axbr[i] + a[i][j] * br[j];` `        ``// Finally check if value of expression``        ``// A * (B*r) - (C*r) is 0 or not``        ``for` `(``int` `i = ``0``; i < N; i++)``            ``if` `(axbr[i] - cr[i] != ``0``)``                ``return` `false``;` `        ``return` `true``;``    ``}` `    ``// Runs k iterations Freivald. The value``    ``// of k determines accuracy. Higher value``    ``// means higher accuracy.``    ``static` `boolean` `isProduct(``int` `a[][], ``int` `b[][], ``                                 ``int` `c[][], ``int` `k)``    ``{``        ``for` `(``int` `i = ``0``; i < k; i++)``            ``if` `(freivald(a, b, c) == ``false``)``                ``return` `false``;``        ``return` `true``;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String args[])``    ``{``        ``int` `a[][] = { { ``1``, ``1` `}, { ``1``, ``1` `} };``        ``int` `b[][] = { { ``1``, ``1` `}, { ``1``, ``1` `} };``        ``int` `c[][] = { { ``2``, ``2` `}, { ``2``, ``2` `} };``        ``int` `k = ``2``;``        ``if` `(isProduct(a, b, c, k))``            ``System.out.println(``"Yes"``);``        ``else``            ``System.out.println(``"No"``);``    ``}``}` `/*This code is contributed by Nikita Tiwari.*/`

## Python3

 `# Python3 code to implement Freivald’s Algorithm``import` `random ``N ``=` `2` `# Function to check if ABx = Cx``def` `freivald(a, b, c) :``    ` `    ``# Generate a random vector``    ``r ``=` `[``0``] ``*` `N``    ` `    ``for` `i ``in` `range``(``0``, N) :``        ``r[i] ``=` `(``int``)(random.randrange(``509090009``) ``%` `2``)` `    ``# Now compute B*r for evaluating``    ``# expression A * (B*r) - (C*r)``    ``br ``=` `[``0``] ``*` `N``    ` `    ``for` `i ``in` `range``(``0``, N) :``        ``for` `j ``in` `range``(``0``, N) :``            ``br[i] ``=` `br[i] ``+` `b[i][j] ``*` `r[j]` `    ``# Now compute C*r for evaluating``    ``# expression A * (B*r) - (C*r)``    ``cr ``=` `[``0``] ``*` `N``    ``for` `i ``in` `range``(``0``, N) :``        ``for` `j ``in` `range``(``0``, N) :``            ``cr[i] ``=` `cr[i] ``+` `c[i][j] ``*` `r[j]` `    ``# Now compute A* (B*r) for evaluating``    ``# expression A * (B*r) - (C*r)``    ``axbr ``=` `[``0``] ``*` `N``    ``for` `i ``in` `range``(``0``, N) :``        ``for` `j ``in` `range``(``0``, N) :``            ``axbr[i] ``=` `axbr[i] ``+` `a[i][j] ``*` `br[j]` `    ``# Finally check if value of expression``    ``# A * (B*r) - (C*r) is 0 or not``    ``for` `i ``in` `range``(``0``, N) :``        ``if` `(axbr[i] ``-` `cr[i] !``=` `0``) :``            ``return` `False``            ` `    ``return` `True` `# Runs k iterations Freivald. The value``# of k determines accuracy. Higher value``# means higher accuracy.``def` `isProduct(a, b, c, k) :``    ` `    ``for` `i ``in` `range``(``0``, k) :``        ``if` `(freivald(a, b, c) ``=``=` `False``) :``            ``return` `False``    ``return` `True` `# Driver code``a ``=` `[ [ ``1``, ``1` `], [ ``1``, ``1` `] ]``b ``=` `[ [ ``1``, ``1` `], [ ``1``, ``1` `] ]``c ``=` `[ [ ``2``, ``2` `], [ ``2``, ``2` `] ]``k ``=` `2` `if` `(isProduct(a, b, c, k)) :``    ``print``(``"Yes"``)``else` `:``    ``print``(``"No"``)` `# This code is contributed by Nikita Tiwari`

## C#

 `// C# code to implement ``// Freivald's Algorithm``using` `System;` `class` `GFG ``{``    ``static` `int` `N = 2;` `    ``// Function to check``    ``// if ABx = Cx``    ``static` `bool` `freivald(``int` `[,]a, ``                         ``int` `[,]b,``                         ``int` `[,]c)``    ``{``        ``// Generate a ``        ``// random vector``        ``Random rand = ``new` `Random();``        ``int` `[]r = ``new` `int``[N];``        ` `        ``for` `(``int` `i = 0; i < N; i++)``        ``r[i] = (``int``)(rand.Next()) % 2;` `        ``// Now compute B*r for ``        ``// evaluating expression``        ``// A * (B*r) - (C*r)``        ``int` `[]br = ``new` `int``[N];``        ` `        ``for` `(``int` `i = 0; i < N; i++)``            ``for` `(``int` `j = 0; j < N; j++)``                ``br[i] = br[i] + ``                        ``b[i, j] * r[j];` `        ``// Now compute C*r for ``        ``// evaluating expression ``        ``// A * (B*r) - (C*r)``        ``int` `[]cr = ``new` `int``[N];``        ` `        ``for` `(``int` `i = 0; i < N; i++)``            ``for` `(``int` `j = 0; j < N; j++)``                ``cr[i] = cr[i] + ``                        ``c[i, j] * r[j];` `        ``// Now compute A* (B*r) for``        ``// evaluating expression ``        ``// A * (B*r) - (C*r)``        ``int` `[]axbr = ``new` `int``[N];``        ` `        ``for` `(``int` `i = 0; i < N; i++)``            ``for` `(``int` `j = 0; j < N; j++)``                ``axbr[i] = axbr[i] + ``                          ``a[i, j] * br[j];` `        ``// Finally check if value ``        ``// of expression A * (B*r) - ``        ``// (C*r) is 0 or not``        ``for` `(``int` `i = 0; i < N; i++)``            ``if` `(axbr[i] - cr[i] != 0)``                ``return` `false``;` `        ``return` `true``;``    ``}` `    ``// Runs k iterations Freivald.``    ``// The value of k determines``    ``// accuracy. Higher value``    ``// means higher accuracy.``    ``static` `bool` `isProduct(``int` `[,]a, ``int` `[,]b, ``                          ``int` `[,]c, ``int` `k)``    ``{``        ``for` `(``int` `i = 0; i < k; i++)``            ``if` `(freivald(a, b, c) == ``false``)``                ``return` `false``;``        ``return` `true``;``    ``}` `    ``// Driver code``    ``static` `void` `Main()``    ``{``        ``int` `[,]a = ``new` `int``[,]{ { 1, 1 }, ``                               ``{ 1, 1 }};``        ``int` `[,]b = ``new` `int``[,]{ { 1, 1 }, ``                               ``{ 1, 1 }};``        ``int` `[,]c = ``new` `int``[,]{ { 2, 2 }, ``                               ``{ 2, 2 }};``        ``int` `k = 2;``        ``if` `(isProduct(a, b, c, k))``            ``Console.WriteLine(``"Yes"``);``        ``else``            ``Console.WriteLine(``"No"``);``    ``}``}``// This code is contributed ``// by Manish Shaw(manishshaw1)`

## PHP

 ``

## Javascript

 ``

Output:
`Yes`

Time Complexity: O(N ^ 2)
Auxiliary Space: O(N )

Previous
Next