Given a positive integer** N**, the task is to find the number of **Antisymmetric ****Relations** on the given set of **N** elements. Since the number of relations can be very large, so print it modulo 10^{9}+7.

A relation

Ron a setAis calledAntisymmetricif and only if(a, b) € Rand(b, a) € R, thena = bis called antisymmetric, i.e., the relationR = {(a, b)→ R | a ≤ b} is anti-symmetric, sincea ≤ bandb ≤ aimpliesa = b.

**Examples:**

Input:N = 2Output:12Explanation:Considering the set {a, b}, all possible antisymmetric relations are:

{}, {(a, b)}, {(b, a)}, {(a, a)}, {(a, a), (a, b)}, {(a, a), (b, a)}, {(b, b)}, {(b, b), (a, b)}, {(b, b), (b, a)}, {(a, a), (b, b)}, {(a, a), (b, b), (a, b)}, {(a, a), (b, b), (b, a)}.

Input:N = 5Output:1889568

**Approach:** The given problem can be solved based on the following observations:

- Considering an antisymmetric relation
on set**R****S,**say**a****,****b****∈****A****a****≠**then**b,****relation**must not contain both**R****(a, b)**and**(b, a)**. It may contain one of the ordered pairs or neither of them. - There are
**3**possible choices for all pairs. - Therefore, the count of all combinations of these choices is equal to
**3**^{(N*(N – 1))/2}. - The number of subsets of pairs of the form
**(a, a)**is equal to**2**.^{N}

Therefore, the total count of possible antisymmetric relations is equal to **2 ^{N }***

**3**

^{(N*(N – 1))/2}.Below is the implementation of the above approach:

## C++

`// C++ program for the above approach` `#include <iostream>` `using` `namespace` `std;` `const` `int` `mod = 1000000007;` `// Function to calculate the` `// value of x ^ y % mod in O(log y)` `int` `power(` `long` `long` `x, unsigned ` `int` `y)` `{` ` ` `// Stores the result of x^y` ` ` `int` `res = 1;` ` ` `// Update x if it exceeds mod` ` ` `x = x % mod;` ` ` `while` `(y > 0) {` ` ` `// If y is odd, then` ` ` `// multiply x with result` ` ` `if` `(y & 1)` ` ` `res = (res * x) % mod;` ` ` `// Divide y by 2` ` ` `y = y >> 1;` ` ` `// Update the value of x` ` ` `x = (x * x) % mod;` ` ` `}` ` ` `// Return the resultant` ` ` `// value of x^y` ` ` `return` `res;` `}` `// Function to count the number of` `// antisymmetric relations in a set` `// consisting of N elements` `int` `antisymmetricRelation(` `int` `N)` `{` ` ` `// Print the count of` ` ` `// antisymmetric relations` ` ` `return` `(power(2, N) * 1LL * power(3, (N * N - N) / 2)) % mod;` `}` `// Driver Code` `int` `main()` `{` ` ` `int` `N = 2;` ` ` `cout << antisymmetricRelation(N);` ` ` `return` `0;` `}` |

## Java

`// Java program for the above approach` `import` `java.util.*;` `class` `GFG{` ` ` `static` `int` `mod = ` `1000000007` `;` `// Function to calculate the` `// value of x ^ y % mod in O(log y)` `static` `int` `power(` `int` `x, ` `int` `y)` `{` ` ` ` ` `// Stores the result of x^y` ` ` `int` `res = ` `1` `;` ` ` `// Update x if it exceeds mod` ` ` `x = x % mod;` ` ` `while` `(y > ` `0` `) ` ` ` `{` ` ` ` ` `// If y is odd, then` ` ` `// multiply x with result` ` ` `if` `((y & ` `1` `) != ` `0` `)` ` ` `res = (res * x) % mod;` ` ` `// Divide y by 2` ` ` `y = y >> ` `1` `;` ` ` `// Update the value of x` ` ` `x = (x * x) % mod;` ` ` `}` ` ` `// Return the resultant` ` ` `// value of x^y` ` ` `return` `res;` `}` `// Function to count the number of` `// antisymmetric relations in a set` `// consisting of N elements` `static` `int` `antisymmetricRelation(` `int` `N)` `{` ` ` ` ` `// Print the count of` ` ` `// antisymmetric relations` ` ` `return` `(power(` `2` `, N) * ` ` ` `power(` `3` `, (N * N - N) / ` `2` `)) % mod;` `}` `// Driver Code` `public` `static` `void` `main(String []args)` `{` ` ` `int` `N = ` `2` `;` ` ` ` ` `System.out.print(antisymmetricRelation(N));` `}` `}` `// This code is contributed by ipg2016107` |

## Python3

`# Python3 program for the above approach` `mod ` `=` `1000000007` `# Function to calculate the` `# value of x ^ y % mod in O(log y)` `def` `power(x, y):` ` ` `# Stores the result of x^y` ` ` `res ` `=` `1` ` ` `# Update x if it exceeds mod` ` ` `x ` `=` `x ` `%` `mod` ` ` `while` `(y > ` `0` `):` ` ` `# If y is odd, then` ` ` `# multiply x with result` ` ` `if` `(y & ` `1` `):` ` ` `res ` `=` `(res ` `*` `x) ` `%` `mod` ` ` `# Divide y by 2` ` ` `y ` `=` `y >> ` `1` ` ` `# Update the value of x` ` ` `x ` `=` `(x ` `*` `x) ` `%` `mod` ` ` `# Return the resultant` ` ` `# value of x^y` ` ` `return` `res` `# Function to count the number of` `# antisymmetric relations in a set` `# consisting of N elements` `def` `antisymmetricRelation(N):` ` ` `# Print the count of` ` ` `# antisymmetric relations` ` ` `return` `(power(` `2` `, N) ` `*` ` ` `power(` `3` `, (N ` `*` `N ` `-` `N) ` `/` `/` `2` `)) ` `%` `mod` `# Driver Code` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` `N ` `=` `2` ` ` ` ` `print` `(antisymmetricRelation(N))` `# This code is contributed by ukasp` |

## C#

`// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG{` `static` `int` `mod = 1000000007;` `// Function to calculate the` `// value of x ^ y % mod in O(log y)` `static` `int` `power(` `int` `x, ` `int` `y)` `{` ` ` ` ` `// Stores the result of x^y` ` ` `int` `res = 1;` ` ` `// Update x if it exceeds mod` ` ` `x = x % mod;` ` ` `while` `(y > 0)` ` ` `{` ` ` `// If y is odd, then` ` ` `// multiply x with result` ` ` `if` `((y & 1)>0)` ` ` `res = (res * x) % mod;` ` ` `// Divide y by 2` ` ` `y = y >> 1;` ` ` `// Update the value of x` ` ` `x = (x * x) % mod;` ` ` `}` ` ` `// Return the resultant` ` ` `// value of x^y` ` ` `return` `res;` `}` `// Function to count the number of` `// antisymmetric relations in a set` `// consisting of N elements` `static` `int` `antisymmetricRelation(` `int` `N)` `{` ` ` `// Print the count of` ` ` `// antisymmetric relations` ` ` `return` `(power(2, N) * ` ` ` `power(3, (N * N - N) / 2)) % mod;` `}` `// Driver Code` `public` `static` `void` `Main()` `{` ` ` `int` `N = 2;` ` ` ` ` `Console.Write(antisymmetricRelation(N));` `}` `}` `// This code is contributed by SURENDRA_GANGWAR` |

**Output:**

12

**Time Complexity:** O(log N)**Auxiliary Space: **O(1)

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the **Essential Maths for CP Course** at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**