गणित में फ़ंक्शन क्या है? एक सहज समझ

उदीयमान और जूनियर डेटा साइंटिस्ट अक्सर "फ़ंक्शन" शब्द देखते हैं, लेकिन हमेशा स्पष्ट नहीं होता कि इसका अर्थ वास्तव में क्या है। 

इस लेख में, आप जानेंगे कि गणितीय फ़ंक्शन क्या होता है, कौन-से समुच्चय इसके इनपुट और आउटपुट मानों का वर्णन करते हैं, और सतत तथा असतत मानों में क्या अंतर होता है। आप यह भी देखेंगे कि तकनीक में फ़ंक्शनों का उपयोग कैसे होता है, डेटा साइंस में प्रचलित फ़ंक्शन कौन-से हैं, और उन्हें कैसे ऑप्टिमाइज़ किया जाता है। रास्ते में, आप फ़ंक्शनों को संशोधित और प्लॉट करने के लिए Python कोड भी देखेंगे।

यदि आप Python में अपने स्वयं के फ़ंक्शन लिखने और उपयोग करने का अभ्यास करना चाहते हैं, तो मैं हमारा Writing Functions in Python कोर्स लेने की सलाह देता/देती हूँ।

गणित में फ़ंक्शन क्या है?

गणित में, फ़ंक्शन हर इनपुट को एक अद्वितीय आउटपुट से जोड़ता है। प्रत्येक वैध इनपुट केवल और केवल एक आउटपुट देता है। किसी इनपुट के एक से अधिक आउटपुट नहीं हो सकते।

उदाहरण के लिए, 32 डिग्री फ़ारेनहाइट 0 सेल्सियस होता है। फ़ारेनहाइट का मान सेल्सियस के एक मान से मेल खाता है; और वह भी केवल एक मान से। आप एक वैध इनपुट (फ़ारेनहाइट) के लिए दो अलग-अलग आउटपुट (सेल्सियस) नहीं रख सकते। 

अन्य उदाहरणों में पेरोल शामिल है, जहाँ आपको प्रति घंटा एक राशि का भुगतान किया जाता है। यदि आप $20 प्रति घंटा कमाते हैं और 40 घंटे काम करते हैं, तो आप 20 x 40 = $800 कमाते हैं।

सभी नियम फ़ंक्शन नहीं होते। कुछ मामलों में, एक इनपुट के लिए कई आउटपुट होना तार्किक रूप से समझ में आता है। उदाहरण के लिए, किसी नाम को किसी व्यक्ति से मिलाना फ़ंक्शन नहीं है। "John Smith" नाम कई लोगों से मेल खा सकता है, जो सभी यह नाम साझा करते हैं।

गणित में, नियम अक्सर इस तरह बनाए जाते हैं कि प्रत्येक वैध इनपुट के लिए केवल एक आउटपुट हो। कई मामलों में, दुनिया वास्तव में इसी तरह काम करती है (पेरोल)। अन्य मामलों में, समस्याएँ फ़ंक्शनों के रूप में इसीलिए गढ़ी जाती हैं क्योंकि इससे समस्या सुलझने योग्य बनती है। उलझे हुए इनपुट‑आउटपुट जाल का पीछा करने के बजाय, मॉडल इस तरह सेट किया जाता है कि किसी इनपुट के कई आउटपुट न हों।

आप किसी फ़ंक्शन को एक "मशीन" की तरह समझ सकते हैं जो एक इनपुट (अक्सर x) लेती है, उसे किसी तरह प्रोसेस करती है, और एक आउटपुट (अक्सर y) देती है।

यहाँ, एक मशीन बाएँ तरफ़ अपनी कन्वेयर बेल्ट से इनपुट लेती है, उसे प्रोसेस करती है, और दाईं ओर एक हरे टिक मार्क के रूप में आउटपुट पैदा करती है।

मल्टीवेरिएट फ़ंक्शन कई इनपुट्स के एक समूह को स्वीकार करते हैं लेकिन केवल एक आउटपुट देते हैं। आप इसे ऐसे समझ सकते हैं जैसे कई चरों या फीचर्स वाली एक डेटा पंक्ति को पास करना जो एकल आउटपुट से मैप होती है।

फ़ंक्शन संकेतांकन और पारिभाषिकी

समीकरण कैसे लिखते हैं? तापमान रूपांतरण उदाहरण में, हम सूत्र को y = f(x) = (5/9) (x - 32) के रूप में लिख सकते हैं, जहाँ x फ़ारेनहाइट में तापमान है और y सेल्सियस में। इस संकेतांकन को समझने के लिए, इसे बाएँ से दाएँ पढ़ें। 

बाएँ ओर y है, जो आउटपुट है। f(x) संकेत करता है कि आप f नामक फ़ंक्शन का उपयोग कर रहे हैं, जो एक इनपुट x लेता है। ध्यान दें कि इस संदर्भ में f(x) का अर्थ किसी मान f का किसी अन्य मान x से गुणन नहीं है। 

दाएँ ओर सूत्र है। यह कहता है कि इनपुट x लें, उसमें से 32 घटाएँ, और परिणाम को 5/9 से गुणा करें।

डोमेन, कोडोमेन, और रेंज

मान लीजिए आप रोज़ एक बार बाहरी तापमान दर्ज करते हैं और आपने k माप एकत्र किए हैं, जिन्हें (x1, x2, …, xk) से सूचित किया गया है। आप एक ऐसा फ़ंक्शन चाहते हैं जो n दिन बीतने के बाद वर्ष‑तिथि औसत तापमान लौटाए। एक ऐसा फ़ंक्शन परिभाषित करें जो एक धनात्मक पूर्णांक n (जो k से कम या बराबर हो) लेता है और पहले n तापमानों का औसत लौटाता है, जो एक वास्तविक संख्या है। ऐसे फ़ंक्शन के लिए संकेतांकन है f: {1, 2, …, k} → ℝ.

फ़ंक्शन में शामिल समुच्चयों का वर्णन करने के लिए कुछ जार्गन होना सहायक होता है, जो हमें डोमेन, कोडोमेन और रेंज तक ले जाता है। 

• डोमेन उस समुच्चय का नाम है जो इनपुट्स का वर्णन करता है, इस मामले में पूर्णांक। 
• कोडोमेन वह समुच्चय है जो आपके इच्छित आउटपुट के प्रकार का वर्णन करता है, इस मामले में वास्तविक संख्याएँ।

अब, रेंज पर नज़र डालते हैं। एक साधारण द्विघात फ़ंक्शन पर विचार करें: y = f(x) = x2. डोमेन और कोडोमेन निर्दिष्ट करने के लिए, लिखें f: ℝ → ℝ. 

अब आप जानते हैं कि यह संकेत करता है कि डोमेन (इनपुट का समुच्चय) और कोडोमेन (आउटपुट का समुच्चय) दोनों वास्तविक संख्याओं से बने हैं। हालाँकि, थोड़ा सोचने पर, आप महसूस करेंगे कि आउटपुट का समुच्चय सभी वास्तविक संख्याएँ नहीं हो सकता। 

क्योंकि किसी भी संख्या का वर्ग गैर‑ऋणात्मक होता है, तो वास्तव में प्राप्त होने वाले आउटपुट सभी वास्तविक संख्याएँ नहीं, बल्कि केवल गैर‑ऋणात्मक वास्तविक संख्याएँ हैं। इस स्थिति का वर्णन करने के लिए प्रयुक्त शब्द है रेंज। हम कहते हैं कि इस फ़ंक्शन की रेंज सभी गैर‑ऋणात्मक वास्तविक संख्याएँ हैं। 

कोडोमेन संभावित आउटपुट का समुच्चय है; रेंज वास्तव में प्राप्त आउटपुट का समुच्चय है। आप कोडोमेन को अपने इच्छित आउटपुट के प्रकार के अनुरूप चुनते हैं, और रेंज का पता लगाते हैं, जो वास्तव में प्राप्त आउटपुट मानों का समुच्चय है।

सतत और असतत चर

यह हमें सतत और असतत चरों के अंतर तक लाता है:

• सतत चर किसी दिए गए दायरे में हर सैद्धांतिक मान ग्रहण कर सकते हैं। 
• असतत चर सीमित या गिनने योग्य संख्या के मान ग्रहण करते हैं। 

उदाहरण के लिए, [0, 1] में एक सतत चर 0, 0.5, 0.4141, या इस दायरे में कोई भी वास्तविक मान ले सकता है। सतत चर उन मॉडलों में सामान्य हैं जहाँ आउटपुट सैद्धांतिक रूप से कोई भी मान हो सकता है, जैसे रिग्रेशन में।

हालाँकि, बाइनरी क्लासिफिकेशन में, आपको केवल दो मानों की चिंता होती है: 0 और 1। उदाहरण के लिए, किसी तस्वीर में या तो बिल्ली है या नहीं है। एक मल्टी‑क्लास क्लासिफिकेशन समस्या में भी, आपके पास सीमित संख्या के मान होते हैं, जैसे 0 कुत्ते के लिए, 1 बिल्ली के लिए, 2 घोड़े के लिए।

आप जिस समस्या को हल करना चाहते हैं, वही तय करती है कि आपको किस तरह के फ़ंक्शन में दिलचस्पी है। क्लासिफिकेशन समस्याएँ असतत मान देती हैं; रिग्रेशन समस्याएँ सतत फ़ंक्शन देती हैं।

वेक्टर संकेतांकन

कभी‑कभी आपको किसी फ़ंक्शन में कई चरों को पास करना पड़ता है। उदाहरण के लिए, आप किसी मशीन लर्निंग फ़ंक्शन में फीचर्स की एक पंक्ति पास कर सकते हैं। इस स्थिति में, आप फीचर्स को एक कंटेनर में समूहित कर सकते हैं और उसे पास कर सकते हैं। डेटा को इस तरह एक कंटेनर में समूहित करने का एक तरीका है वेक्टर। मॉडल एक इनपुट वेक्टर x = [x1, x2, x3] लेता है और एक लक्ष्य y आउटपुट करता है।

Python में, आप आमतौर पर एक NumPy array का उपयोग वेक्टर को निरूपित करने के लिए करते हैं।

import numpy as np

def f(x):
    result = (x[0] + x[1] + x[2]) / 3
    return result

x = [3, 4, 7.1]
print(f(x))संचालित द्वारा

4.7संचालित द्वारा

यह कोड 3, 4 और 7.1 संख्याओं से बने एक वेक्टर को लेता है और एक औसत लौटाता है।

वेक्टरों के एक समूह के लिए, एक लोकप्रिय तरीका है pandas लाइब्रेरी की DataFrame डेटा संरचना का उपयोग करना। 

import pandas as pd

def row_averages(df):
    return df.mean(axis=1).round(1)

df = pd.DataFrame({
    "A": [1, 5, 2],
    "B": [9, 3, 6],
    "C": [7, 8, 10]
})

print(row_averages(df))संचालित द्वारा

यह कोड पंक्ति‑औसतों वाला एक pandas Series लौटाता है, प्रति पंक्ति एक मान। इस मामले में:

0    5.7
1    5.3
2    6.0संचालित द्वारा

प्रौद्योगिकी में फ़ंक्शन

प्रौद्योगिकी में फ़ंक्शन की अवधारणा सर्वव्यापी है। व्यावहारिक कारणों से, ध्यान रखें कि तकनीक में "फ़ंक्शन" हमेशा गणित जितना सख्ती से परिभाषित नहीं होता। उदाहरण के लिए, प्रोग्रामिंग फ़ंक्शन ऐसे साइड इफेक्ट्स कर सकते हैं जो आउटपुट के अलावा अन्य वेरिएबल्स के मान बदल दें, जबकि गणितीय फ़ंक्शनों में ऐसा नहीं होता।

स्प्रेडशीट्स

फ़ंक्शनों का स्प्रेडशीट्स में व्यापक उपयोग होता है, जैसे कि Excel फ़ॉर्मूला में। आप किसी संख्यात्मक कॉलम का जोड़, माध्य या माध्यिका निकालना चाह सकते हैं। स्प्रेडशीट्स के लिए, फ़ंक्शन पहले बताई गई गणितीय परिभाषा का ही अनुसरण करते हैं।

स्प्रेडशीट्स जिस एक चीज़ में उत्कृष्ट हैं (जानबूझकर किया गया मज़ाक) वह है शर्तीय फ़ंक्शन: ये आपको IF() जैसे फ़ंक्शनों का उपयोग कर अधिक जटिल शर्तीय संरचनाएँ बनाने देते हैं। 

उदाहरण के लिए, आप एक वर्ष के दौरान अपने मॉर्गेज कंपनी को किए गए भुगतानों का कुल निकालना चाह सकते हैं। ऐसा करने के लिए, आप संभवतः अपनी स्प्रेडशीट के SUM() फ़ंक्शन का उपयोग करेंगे।

प्रोग्रामिंग भाषाएँ

प्रोग्रामिंग भाषाओं में फ़ंक्शन सर्वत्र पाए जाते हैं। प्रोग्रामिंग भाषा के आधार पर, "फ़ंक्शन" की परिभाषा गणितीय फ़ंक्शन की तुलना में ढीली हो सकती है। कुछ भाषाएँ एक फ़ंक्शन को कई मान लौटाने देती हैं, या कोई मान न लौटाने देती हैं। 

उदाहरण के लिए, कोई फ़ंक्शन मान ले सकता है और एक कथन प्रिंट कर सकता है, लेकिन स्पष्ट रूप से कोई मान नहीं लौटाता। एक Python फ़ंक्शन कुछ इस तरह दिखता है:

def print_me(name, color):
       print(f"My name is {name} and my favorite color is {color}.")

name = "Mark"
color = "blue"
print_me(name, color)संचालित द्वारा

यह कोड निम्न आउटपुट देता है: "My name is Mark and my favorite color is blue." फ़ंक्शन से कोई गणितीय मान स्पष्ट रूप से वापस नहीं किया जाता।

Python जैसी कई मुख्यधारा की भाषाओं में कोड में किसी फ़ंक्शन के भीतर अन्य साइड इफेक्ट्स भी हो सकते हैं, जैसे किसी ग्लोबल वेरिएबल का मान बदलना। यद्यपि साइड इफेक्ट्स संभव और अनुमत हैं, वे हतोत्साहित किए जाते हैं। साइड इफेक्ट्स प्रोग्रामों का परीक्षण, डिबग और समझना कठिन बनाते हैं।

इन्हीं कारणों से, कुछ "फ़ंक्शनल" भाषाएँ, जैसे Scala और Haskell, फ़ंक्शन के विचार के इर्द‑गिर्द अधिक सख्ती से आधारित हैं। 

मशीन लर्निंग

मशीन लर्निंग के संदर्भ में, इनपुट्स फीचर्स होते हैं, फ़ंक्शन मॉडल होता है, और आउटपुट मॉडल की भविष्यवाणी। ऐसे मॉडल को अक्सर "ब्लैक बॉक्स" कहा जाता है क्योंकि यह आवश्यक नहीं कि स्पष्ट हो कि आउटपुट भविष्यवाणी देने के लिए इनपुट फीचर्स को कैसे प्रोसेस किया गया, इसीलिए हमारा पहले वाला ”मशीन” रूपक और भी उपयुक्त बैठता है:

इस चित्रण में, फीचर्स को मॉडल "मशीन" में फीड किया जाता है, जो उन्हें किसी तरह प्रोसेस कर एक भविष्यवाणी आउटपुट करता है। साधारण, नियतात्मक फ़ंक्शनों (जैसे तापमान रूपांतरण) की तुलना में, मशीन के अंदर क्या होता है, इसका वर्णन करना कठिन होता है।

ML में, डोमेन फीचर वेक्टर होते हैं; कोडोमेन संभावनाएँ, वर्ग, या वास्तविक‑मान वाली भविष्यवाणियाँ हो सकता है।

डीप लर्निंग क्षेत्र में, फ़ंक्शन सामान्यतः सीधे इनपुट के एक सेट पर लागू नहीं किए जाते, बल्कि मॉडल की शुद्धता का आकलन एक कॉस्ट फ़ंक्शन से किया जाता है। कॉस्ट फ़ंक्शन प्रशिक्षण सेट पर किसी मॉडल के गलत होने का एक माप है। यह भविष्यवाणियों की तुलना वास्तविक लेबल्स या मानों से करता है और त्रुटियों को एक एकल संख्या में समेकित करता है।

डेटा साइंस में सामान्य फ़ंक्शन

कुछ फ़ंक्शन डेटा साइंस में लगभग हर जगह दिखते हैं। इनमें रैखिक (linear) फ़ंक्शन, लघुगणकीय (logarithmic) फ़ंक्शन और घातीय (exponential) फ़ंक्शन, साथ ही डीप लर्निंग के लिए नॉन‑लीनियर एक्टिवेशन फ़ंक्शन शामिल हैं।

रैखिक फ़ंक्शन

आइए क्लासिक उदाहरण, रैखिक फ़ंक्शनों से शुरू करें।

ढाल (Slope)

मान लीजिए आपको सेब खाने की इच्छा है। आप एक किराना दुकान पर जाते हैं जो सेब $0.75 प्रति पाउंड के निश्चित दाम पर बेचती है। तो एक पाउंड सेब की कीमत $0.75 है, 2 पाउंड की कीमत 2 x $0.75 = $1.50, और 3 पाउंड की कीमत 3 x $0.75 = $2.25। आप जितने पाउंड खरीदते हैं, प्रत्येक पाउंड कुल लागत में एक निश्चित राशि जोड़ता है।

फ़ंक्शन संकेतांकन में, आप सूत्र को f(x) = 0.75 x लिख सकते हैं। संख्या 0.75 इस रैखिक फ़ंक्शन की ढाल है। ढाल इनपुट में प्रति इकाई परिवर्तन के सापेक्ष आउटपुट के परिवर्तन की दर है।

ऐसे फ़ंक्शन का ग्राफ बनाने के लिए, आप निम्न जैसा कोड उपयोग कर सकते हैं:

import numpy as np
import matplotlib.pyplot as plt

def cost_of_apples(x, m):
    result = m * x
    return result

# Define x and y
x = np.linspace(0, 5, 100)
y = cost_of_apples(x, 0.75)

# Plot
plt.figure()
plt.plot(x, y)
plt.xlabel("Pounds of Apples")
plt.ylabel("Total Cost ($)")
plt.title("Cost of Apples")
plt.show()संचालित द्वारा

ऐसे फ़ंक्शनों को रैखिक फ़ंक्शन कहा जाता है। इनपुट x में प्रत्येक वृद्धि आउटपुट y में एक ही निश्चित राशि का योगदान देती है। जैसा कि नाम से स्पष्ट है, ग्राफ करने पर रैखिक फ़ंक्शन एक सीधी रेखा देता है।

इंटरसेप्ट

अब, मान लीजिए आपको अपनी ग्रॉसरी डिलीवर करवाना पसंद है। किराना दुकान $2.00 का फिक्स्ड डिलीवरी शुल्क लेती है। इस स्थिति में, सेब के लिए आपका फ़ंक्शन होगा f(x) = 0.75 x + 2। पहले की तरह, 0.75 ढाल है। संख्या 2, जहाँ ग्राफ y‑अक्ष को काटता है, "y‑इंटरसेप्ट" कहलाती है। यह वह आउटपुट मान है जब इनपुट 0 होता है। 

कुल लागत सेबों के जोड़ और डिलीवरी शुल्क का योग है। सामान्यतः, एक एकचर (univariate) रैखिक फ़ंक्शन को f(x) = mx + b के रूप में लिखा जा सकता है, जहाँ m को ढाल और b को y‑इंटरसेप्ट कहते हैं। 

मल्टीवेरिएट रैखिक फ़ंक्शन

संभवतः आप केवल सेब ही नहीं, और भी चीज़ें खाना चाहेंगे। मान लीजिए आप ब्रेड और पीनट बटर भी खरीदना चाहते हैं। सेब $0.75 प्रति पाउंड हैं, एक ब्रेड की लोफ $2.50 है, और पीनट बटर का एक जार $3.00 है। अब, आपका ग्रॉसरी बिल फ़ंक्शन है:

यह फ़ंक्शन अभी भी रैखिक माना जाता है क्योंकि यह प्रत्येक चर में रैखिक है। सामान्यतः, एक रैखिक फ़ंक्शन का रूप होता है:

यह आपके प्रत्येक परिमाण को उनके वेट्स (ढाल के लिए इस संदर्भ में प्रयुक्त एक और शब्द) से गुणा कर जोड़ने, और फिर इंटरसेप्ट जोड़ने के बराबर है।

वेक्टर संकेतांकन में, यह फ़ंक्शन इस प्रकार लिखा जाता है:

यहाँ T "ट्रांसपोज़्ड" के लिए है, जो w और x के लिए वेक्टर गुणा करने हेतु आवश्यक है।

रैखिक रिग्रेशन

ईंधन क्षमता बनाम गति पर विचार करें। आपको संदेह है कि जैसे‑जैसे कोई तेज़ ड्राइव करता है, ईंधन क्षमता घटती है। आप 45 से 65 मील प्रति घंटा की गति के बीच पचास डेटा बिंदु एकत्र करते हैं और निम्न पैटर्न देखते हैं:

हर डेटा बिंदु को जोड़ना एक टेढ़ा‑मेढ़ा, पढ़ने में कठिन, अनुपयोगी मॉडल देगा। लेकिन इस दायरे में डेटा का सामान्य रुझान लगभग रैखिक है। यदि हम गति को x कहते हैं, तो इस ग्राफ के लिए फ़ंक्शन है:

ऐसी रेखा खोजने के लिए जो डेटा के लिए सर्वोत्तम फिट हो, आप सिंपल लीनियर रिग्रेशन नामक गणितीय प्रक्रिया का उपयोग करते हैं।

आप Python में Matplotlib और Seaborn का उपयोग कर ऐसी रेखा की गणना कर सकते हैं:

import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

# Reproducibility
np.random.seed(0)

# Create dataset
speed = np.linspace(45, 65, 50)
mpg = 38 - 0.2 * speed + 0.002 * (speed - 55)**2 + np.random.normal(0, 0.5, size=50)

df = pd.DataFrame({
    "speed": speed,
    "mpg": mpg
})

# Plot with regression line
sns.regplot(data=df, x="speed", y="mpg", ci=None)

plt.xlabel("Speed (mph)")
plt.ylabel("Fuel Efficiency (mpg)")
plt.title("Fuel Efficiency vs Speed")
plt.show()संचालित द्वारा

रैखिक रिग्रेशन कई चरों के साथ काम करता है। मान लीजिए आप गति (x), वाहन का वज़न (y), और इंजन का आकार (z) के लिए एक रैखिक रिग्रेशन मॉडल परिभाषित करना चाहते हैं। मल्टीवेरिएट लीनियर रिग्रेशन के लिए परिणामी सूत्र है:

इस मामले में, प्रत्येक चर के गुणांक उस फीचर के वेट या महत्त्व का प्रतिनिधित्व करते हैं, जबकि अन्य चरों को स्थिर माना जाता है। 

इनवर्स फ़ंक्शन

अब, सेब खरीदने के प्रश्न को "उलटते" हैं: यदि आपने सेब पर $2.25 खर्च किए, तो आपने कितने पाउंड खरीदे? उत्तर है 2.25 / 0.75 = 3, तो आपने तीन पाउंड खरीदे। फ़ंक्शन की इस तरह की "उलट" को फ़ंक्शन का इनवर्स कहा जाता है। इंटरसेप्ट के बिना वाले उदाहरण में, इनवर्स है: 

ध्यान दें कि इस संकेतांकन में "-1" का अर्थ है कि आप किसी फ़ंक्शन का इनवर्स ले रहे हैं, न कि व्युत्क्रम (reciprocal)।

एक बात जिस पर ध्यान देना चाहिए वह है कि डोमेन बदल सकता है। उदाहरण के लिए, मान लीजिए आपका मूल फ़ंक्शन है:

यह फ़ंक्शन सभी वास्तविक संख्याओं के लिए परिभाषित है, सिवाय 2 के, क्योंकि हर का हर (denominator) शून्य नहीं हो सकता। इस फ़ंक्शन का इनवर्स है 

उसी कारण से, इनवर्स फ़ंक्शन सभी इनपुट्स के लिए परिभाषित है, 0 को छोड़कर। 

एक और सावधानी यह है कि प्राप्त इनवर्स कई बार फ़ंक्शन नहीं होता क्योंकि एक इनपुट के कई आउटपुट हो सकते हैं। फ़ंक्शन y = x2 पर विचार करें। इसका उलटा इसलिए होगा:

जैसा कि प्लस/माइनस से स्पष्ट है, इनवर्स में एक इनपुट के लिए दो आउटपुट हैं, इसलिए यह फ़ंक्शन नहीं है जब तक कि हम डोमेन को सीमित न करें (उदाहरण के लिए, x ≥ 0)

ग्राफ़िक रूप से, कोई फ़ंक्शन और उसका इनवर्स (यदि अस्तित्व में हो) रेखा y=x के आरपार एक‑दूसरे के दर्पण प्रतिबिंब होते हैं। फ़ंक्शन y = x3 पर विचार करें। इस फ़ंक्शन और उसके इनवर्स का ग्राफ है:

मूल फ़ंक्शन (नीले रंग में) का एक इनवर्स (नारंगी रंग में) है जो रेखा y = x के आरपार परावर्तित है।