Injective Functions Without Fixed Points: A To B
Hey guys! Today, we're diving deep into a super cool problem from the world of discrete mathematics, specifically focusing on functions and a little something called derangements. We've got a set and another set . Our mission, should we choose to accept it, is to figure out the exact number of injective functions from to that also have a special condition: no fixed points. What does that mean, you ask? Well, an injective function, also known as a one-to-one function, means that each element in set maps to a unique element in set . No two elements in can point to the same element in . And the 'no fixed points' part? That means for every element in set , the function doesn't map it to itself, so . This is where the idea of derangements starts to peek its head in, though it's not a direct application because our sets aren't the same size. Let's break this down, step by step, and unravel this mathematical puzzle.
First off, let's get our bearings. We're looking for injective functions, which is a key property. The total number of functions from to is . However, we need injective functions. For an injective function , the first element can be any of the 6 elements in . Then, can be any of the remaining 5 elements in (since it must be different from ). Continuing this, has 4 choices, has 3 choices, and has 2 choices. So, the total number of injective functions from to is . This is our starting pool of functions. Now, we need to apply the 'no fixed points' condition. A fixed point occurs when . Since the domain and codomain are not identical, a fixed point can only occur for elements that are present in both sets. In our case, the elements that can potentially be fixed points are those in the intersection of and , which is itself (since ). So, we are concerned about . The element in cannot be a fixed point because . This problem requires us to use the principle of inclusion-exclusion. We start with the total number of injective functions and then subtract those that have at least one fixed point, add back those with at least two fixed points, and so on.
Let's use the principle of inclusion-exclusion, which is a powerful technique for counting problems like this. Our universe is the set of all injective functions from to . We know |ell{U}| = P(6, 5) = 720. Let be the property that for . We want to find the number of injective functions that have none of these properties. Using the inclusion-exclusion principle, this number is given by:
N = |ell{U}| - igsum_{i \in A} |A_i| + igsum_{i < j \in A} |A_i \cap A_j| - igsum_{i < j < k \in A} |A_i \cap A_j \cap A_k| + igsum_{i < j < k < l \in A} |A_i \cap A_j \cap A_k \cap A_l| - |A_1 \cap A_2 \cap A_3 \cap A_4 \cap A_5|
where is the set of injective functions where . Let's calculate the terms.
Term 1: |ell{U}| = P(6, 5) = 720.
Term 2: igsum_{i \in A} |A_i|. This is the sum of the number of injective functions with at least one fixed point. Consider , where . Since must be injective, the remaining 4 elements of (i.e., ) must map to the remaining 5 elements of (i.e., ) injectively. The number of ways to do this is . Since there are 5 elements in that could be fixed points, and each case is symmetric, the sum is inom{5}{1} imes P(5, 4) = 5 imes 120 = 600.
Term 3: igsum_{i < j \in A} |A_i \cap A_j|. This is the sum of the number of injective functions with at least two fixed points. Consider , where and . The remaining 3 elements of (i.e., ) must map to the remaining 4 elements of (i.e., ) injectively. The number of ways to do this is . There are inom{5}{2} pairs of fixed points. So, the sum is inom{5}{2} imes P(4, 3) = 10 imes 24 = 240.
Term 4: igsum_{i < j < k \in A} |A_i \cap A_j \cap A_k|. This is the sum of the number of injective functions with at least three fixed points. Consider , where . The remaining 2 elements of (i.e., ) must map to the remaining 3 elements of (i.e., ) injectively. The number of ways to do this is . There are inom{5}{3} triplets of fixed points. So, the sum is inom{5}{3} imes P(3, 2) = 10 imes 6 = 60.
Term 5: igsum_{i < j < k < l \in A} |A_i \cap A_j \cap A_k \cap A_l|. This is the sum of the number of injective functions with at least four fixed points. Consider , where . The remaining 1 element of (i.e., ) must map to the remaining 2 elements of (i.e., ) injectively. The number of ways to do this is . There are inom{5}{4} quadruplets of fixed points. So, the sum is inom{5}{4} imes P(2, 1) = 5 imes 2 = 10.
Term 6: . This is the number of injective functions with all five fixed points. . The remaining 0 elements of must map to the remaining 1 element of (i.e., ) injectively. The number of ways to do this is . There is inom{5}{5} quintuplet of fixed points. So, the term is inom{5}{5} imes P(1, 0) = 1 imes 1 = 1.
Now, let's plug these values back into the inclusion-exclusion formula:
So, there are 309 injective functions from to such that for all . Pretty neat, right? This method, the principle of inclusion-exclusion, is a lifesaver for these kinds of counting problems where you need to exclude certain conditions. It might seem a bit involved with all the combinations and permutations, but once you break it down term by term, it becomes quite manageable. It's a fundamental tool in combinatorics and super useful for solving complex counting scenarios. Keep practicing these, and you'll be a counting whiz in no time!
Understanding the 'No Fixed Points' Condition
The concept of 'no fixed points' is crucial here, and it's closely related to derangements. A derangement is a permutation of the elements of a set, such that no element appears in its original position. For instance, if we were permuting the set , a derangement would be a rearrangement like or . In these rearrangements, is not in the first position, is not in the second, and is not in the third. The number of derangements of elements is often denoted by or . The formula for derangements is !n = n! igsum_{k=0}^{n} rac{(-1)^k}{k!}.
However, our problem isn't a pure derangement problem because the domain () and the codomain () are different sets, and importantly, the codomain is larger. If and were the same size, say , and we were looking for injective functions with no fixed points, then we would be looking for the number of derangements of , which is . In that case, would have to be a permutation of , and the condition for all would directly define a derangement.
In our case, and . The condition only applies to the elements in . An element can only be a fixed point if is also an element of . Since is a subset of , all elements are candidates for fixed points. The element cannot be a fixed point because there is no such that and . The inclusion-exclusion principle elegantly handles this by starting with all possible injective functions and systematically subtracting those that violate the 'no fixed points' rule. The structure of the calculation reflects how we're dealing with subsets of that are fixed points. For example, when we consider functions where , we're essentially fixing one element. Then, the remaining elements of need to be mapped injectively to the remaining available elements in . The size of the available elements in is . So, we need to find injective mappings from the remaining 4 elements of to these 5 elements of , which is . This logic extends to considering two, three, or more fixed points, where the available pool of elements in shrinks accordingly. The beauty of inclusion-exclusion is that it accounts for overcounting and undercounting that would arise from a simpler approach. It ensures that each function is counted exactly once according to whether it satisfies the condition or not.
Why Inclusion-Exclusion is the Go-To Method
So, why did we resort to the inclusion-exclusion principle? Couldn't there be a simpler way? Well, for problems involving 'at least one' or 'none' conditions, inclusion-exclusion is often the most direct and robust method, especially when the conditions are complex or overlapping. Imagine trying to count the functions with no fixed points directly. You'd have to consider , and , and , and so on, simultaneously. This gets complicated quickly because the choices for one element's mapping are dependent on the choices for others, not just for injectivity but also for the 'no fixed point' rule.
For example, if we try to map first: it can be any element in except . So there are 5 choices. Then for , it can be any element in except and it must be different from . This dependency makes direct counting very tricky. The number of available options for changes depending on whether was (which is disallowed anyway) or some other number. It's a combinatorial minefield!
Inclusion-exclusion flips the problem around. Instead of directly counting what we want (no fixed points), we count the complement: functions with fixed points. We start with the total number of injective functions. Then, we subtract the number of functions with at least one fixed point. But wait, functions with two fixed points were subtracted twice (once for each fixed point), so we add them back. Functions with three fixed points were subtracted three times and added back three times, so they are now counted zero times – we need to subtract them. This back-and-forth continues until we've accounted for all possibilities. The structure of the terms in the inclusion-exclusion formula naturally handles the overlapping conditions (multiple fixed points).
igsum_{i \in A} |A_i| counts functions with OR OR ... igsum_{i < j \in A} |A_i \cap A_j| subtracts functions with AND OR AND OR ...
Each term inom{n}{k} P(|B|-k, |A|-k) represents the number of ways to choose fixed points and then map the remaining elements of injectively into the remaining elements of . This systematic approach ensures that every injective function is correctly classified based on its fixed points, and by the end of the summation, we are left with precisely the count of functions that have zero fixed points.
This method is a cornerstone of combinatorics and is essential for tackling problems that involve counting objects that satisfy certain properties, especially when those properties can coexist. It's a bit like untangling a knot by carefully loosening and tightening different parts until the whole thing is resolved. And the result, 309, is the precise number of injective functions from our set to that steer clear of having any element map to itself. Pretty cool, huh?