**π‘ Problem Formulation:** When dealing with mathematical relations, specifically functions, it is crucial to distinguish whether a given set of ordered pairs (domain and range) forms a function. A set forms a function if each element in the domain maps to exactly one element in the range. In Python, this can be programmatically verified. Imagine an input consisting of a list of ordered pairs, such as `[('a', 1), ('b', 2), ('a', 3)]`

, the desired output should indicate whether these pairs represent a function.

## Method 1: Using a Dictionary to Validate Uniqueness

This method involves iterating over the pairs and adding them into a dictionary. The uniqueness of the mapping from each domain element to a range element adheres to the definition of a function. If any domain element is associated with more than one range element, the relation is not a function.

Here’s an example:

def is_function(pairs): mapping = {} for key, value in pairs: if key in mapping and mapping[key] != value: return False mapping[key] = value return True # Example usage pairs_input = [('a', 1), ('b', 2), ('c', 3)] print(is_function(pairs_input))

Output: `True`

This snippet defines the `is_function`

function, which creates a dictionary, mapping domain elements to range elements. If a domain element is already in the dictionary with a different range element, the function returns `False`

; otherwise, it returns `True`

.

## Method 2: Checking Pair Uniqueness with Set Comprehension

Utilizing set comprehension, this method creates a set of domain elements and compares its size to the original list length. A discrepancy indicates duplicate domain elements mapping to distinct range elements, violating the function definition.

Here’s an example:

def is_function(pairs): return len(set(key for key, _ in pairs)) == len(pairs) # Example usage pairs_input = [('a', 1), ('b', 2), ('a', 3)] print(is_function(pairs_input))

Output: `False`

In this function, a set of domain elements is created using set comprehension. If the set’s length equals the list’s length, all domain elements are unique, implying a function; if not, duplication exists and it’s not a function.

## Method 3: Leveraging defaultdict for Domain Tracking

The `collections.defaultdict`

class from Pythonβs standard library provides a clean way to track domain elements’ mappings. If any domain element is associated with multiple range elements, the relation fails to meet the function criteria.

Here’s an example:

from collections import defaultdict def is_function(pairs): domain_map = defaultdict(set) for key, value in pairs: domain_map[key].add(value) if len(domain_map[key]) > 1: return False return True # Example usage pairs_input = [('a', 1), ('a', 1), ('b', 2)] print(is_function(pairs_input))

Output: `True`

The code defines a function that uses a `defaultdict`

to create sets of range elements for each domain element. If any set’s size is greater than one, there are multiple values associated with that domain, and the function returns `False`

.

## Method 4: Utilizing Frozenset for Immutable Pair Validation

Using frozenset for domain and range pair evaluation ensures immutability and hashability. This method offers a more elegant, functional approach to evaluate if domain elements map uniquely to range elements.

Here’s an example:

def is_function(pairs): domain = frozenset(key for key, _ in pairs) return len(domain) == len(pairs) # Example usage pairs_input = [('a', 2), ('b', 3), ('c', 4)] print(is_function(pairs_input))

Output: `True`

Using a `frozenset`

, the function creates an immutable set of domain elements. If the length of the frozenset equals the list length, it returns `True`

, otherwise it indicates non-unique domain elements, and returns `False`

.

## Bonus One-Liner Method 5: Using map and len in a single Expression

This one-liner method combines `map`

and `len`

to quickly determine if domain elements uniquely map to range elements, making it an elegant concise solution.

Here’s an example:

# Given pairs pairs_input = [('a', 3), ('b', 3), ('a', 3)] # One-liner function application is_function = len(dict(pairs_input)) == len(pairs_input) print(is_function)

Output: `True`

This one-liner first constructs a dictionary from the input pairs, automatically filtering out duplicate keys, then checks if this dictionary’s length matches the input list’s length.

## Summary/Discussion

**Method 1:**Using a Dictionary to Validate Uniqueness. Highly intuitive and easy to read. The overhead of maintaining a dictionary could be a concern with large datasets.**Method 2:**Checking Pair Uniqueness with Set Comprehension. More concise than the first method; however, it overlooks cases where the same domain maps to the same range multiple times.**Method 3:**Leveraging defaultdict for Domain Tracking. Efficient for tracking and can handle larger datasets; however, it is slightly more complex than other methods.**Method 4:**Utilizing Frozenset for Immutable Pair Validation. This functional approach ensures immutability but may be unfamiliar to some Python users.**Bonus Method 5:**Using map and len in a single Expression. Extremely concise and takes advantage of built-in Python functionalities. It may be less readable for beginners or those less acquainted with Python idioms.