Computer programming has been, largely, an intuitive activity.

கணினி நிரலாக்கம் பெரும்பாலும் உள்ளுணர்வு சார்ந்த ஒரு நடவடிக்கையாக இருந்து வருகிறது.


Programmers are taught to understand programming in operational terms, i.e., how a computer executes a program.

நிரலாக்கர்கள், கணினி எவ்வாறு ஒரு நிரலை இயக்குகிறது என்பது போன்ற செயல்பாட்டு ரீதியாக நிரலாக்கத்தைப் புரிந்து கொள்ள கற்றுக்கொடுக்கப்படுகிறார்கள்.


As the field has matured, we see many effective theories for designing and reasoning about computer programs in specific domains.

இந்தத் துறை முதிர்ச்சியடைந்ததால், குறிப்பிட்ட களங்களில் கணினி நிரல்களை வடிவமைப்பதற்கும், அவற்றைப் பற்றிய காரணங்களை உருவாக்குவதற்கும் பல பயனுள்ள கோட்பாடுகளைக் காண்கிறோம்.


Such theories reduce the mental effort, and the amount of experimentation needed to design a product.

இத்தகைய கோட்பாடுகள் மனரீதியான முயற்சியையும், ஒரு பொருளை வடிவமைக்கத் தேவையான பரிசோதனைகளின் அளவையும் குறைக்கின்றன.


They are as indispensable for their domains as calculus is for solving scientific and engineering problems.

அவை அறிவியல் மற்றும் பொறியியல் பிரச்சனைகளைத் தீர்ப்பதற்கு கால்குலஸ் எவ்வளவு இன்றியமையாததோ, அதேபோல அவற்றின் களங்களுக்கும் இன்றியமையாதவை.


I am attracted to effective theories primarily because they save labor (for the human and the computer), and secondarily because they give us better assurance about the properties of programs.

பயனுள்ள கோட்பாடுகள் மீது எனக்கு ஆர்வம் அதிகம். ஏனெனில் அவை உழைப்பைச் சேமிக்கின்றன (மனிதனுக்கும் கணினிக்கும்), மேலும் நிரல்களின் பண்புகள் பற்றிய சிறந்த உறுதியை அளிக்கின்றன.


The original inspiration to design a computer science course which illustrates the applications of effective theories in practice came from Elaine Rich and J Moore.

செயல்முறையில் பயனுள்ள கோட்பாடுகளின் பயன்பாடுகளை விளக்கும் ஒரு கணினி அறிவியல் பாடத்திட்டத்தை வடிவமைப்பதற்கான உந்துதல், எலைன் ரிச் மற்றும் ஜே மூர் ஆகியோரிடமிருந்து வந்தது.


I prepared a set of notes and taught the course in the Spring and Fall of 2003.

நான் குறிப்புகளைத் தயாரித்து, 2003 ஆம் ஆண்டு வசந்த காலத்திலும், இலையுதிர் காலத்திலும் பாடத்தை நடத்தினேன்.


The choice of topics and the style of presentation are my own.

பாடங்களின் தேர்வு மற்றும் விளக்கத்தின் நடை ஆகியவை என்னுடையவை.


I have made no effort to be comprehensive.

நான் விரிவாக இருக்க எந்த முயற்சியும் எடுக்கவில்லை.


Greg Plaxton has used my original notes and made extensive revisions; I am grateful to him.

கிரெக் பிளாக்சன் எனது அசல் குறிப்புகளைப் பயன்படுத்தி விரிவான திருத்தங்களைச் செய்துள்ளார்; நான் அவருக்கு நன்றி கூறுகிறேன்.


I am also grateful to the graduate teaching assistants, especially Thierry Joffrain, for helping me revise the notes.

குறிப்புகளைத் திருத்துவதற்கு உதவிய முதுகலை உதவி விரிவுரையாளர்களுக்கும், குறிப்பாக தியரி ஜோஃப்ரைனுக்கும் நான் நன்றி கூறுகிறேன்.


ஆஸ்டின், டெக்சாஸ் ஜெயதேவ் மிஸ்ரா ஆகஸ்ட் 2006


1 உரை சுருக்கம்


2 பிழை கண்டறிதல் மற்றும் திருத்தம்


3 ரகசிய எழுத்து முறை


4 முடிவுறு நிலை இயந்திரங்கள்


5 மறுபயன்பாடு மற்றும் தூண்டல்


6 தொடர்பு தரவுத்தளம்


7 சர பொருத்தம்


The Mariner 4 spacecraft sent photographs of Mars.

மரைனர் 4 விண்கலம் செவ்வாயின் புகைப்படங்களை அனுப்பியது.


Each pixel encoded 64 possible levels of brightness.

ஒவ்வொரு பிக்சலும் 64 சாத்தியமான பிரகாச நிலைகளை குறியீடாக்கியது.


The image will appear grainy after being converted at the receiver.

பெறுநரில் மாற்றியமைத்த பிறகு, படம் துகள்களாகத் தோன்றும்.


We study the simple Reed-Muller code employed by the later Mariners.

பிந்தைய மரைனர்களால் பயன்படுத்தப்பட்ட எளிய ரீட்-முல்லர் குறியீட்டைப் பற்றி நாங்கள் படிக்கிறோம்.


Error correction capability is low with 8- bit codewords.

8-பிட் குறியீட்டு வார்த்தைகளுடன் பிழை திருத்தும் திறன் குறைவாக உள்ளது.


Hadamard matrices have many pleasing properties.

ஹடமார்ட் அணிவரிசைகள் பல இனிமையான பண்புகளைக் கொண்டுள்ளன.


The Hamming distance between any two distinct rows of Hn, n≥1, is 2n-1.

Hn, n≥1 இன் எந்த இரண்டு தனித்துவமான வரிசைகளுக்கும் இடையிலான ஹம்மிங் தூரம் 2n-1 ஆகும்.


Secure communication has been important for at least 2,500 years.

பாதுகாப்பான தொடர்பு குறைந்தது 2,500 ஆண்டுகளாக முக்கியமானது.


Alice will encrypt the plaintext to create a ciphertext.

ஆலிஸ் ஒரு சைட் டெக்ஸ்டை உருவாக்க பிளைன் டெக்ஸ்டை குறியாக்கம் செய்வார்.


The goal of encryption and decryption is to make it hard for Eve to decrypt the ciphertext.

குறியாக்கம் மற்றும் டிகோடிங்கின் நோக்கம், ஈவ் சைட் டெக்ஸ்டை டிகோட் செய்வதை கடினமாக்குவதாகும்.


When Alice and Bob share knowledge of the key, they are using a symmetric key system.

ஆலிஸும், பாபும் விசையைப் பற்றிய அறிவைப் பகிர்ந்து கொள்ளும்போது, அவர்கள் ஒரு சமச்சீர் விசை அமைப்பைப் பயன்படுத்துகிறார்கள்.


Modern public key cryptography is asymmetric.

நவீன பொது விசை கிரிப்டோகிராபி சமச்சீரற்றது.


Alice could write her message on a piece of paper and mail it physically.

ஆலிஸ் தனது செய்தியை ஒரு காகிதத்தில் எழுதி அதை நேரடியாக அனுப்பலாம்.


Any communication medium is vulnerable, so security is achieved by choosing the encryption algorithms carefully.

எந்தவொரு தொடர்பு ஊடகமும் பாதிக்கப்படக்கூடியது, எனவே குறியாக்க வழிமுறைகளை கவனமாகத் தேர்ந்தெடுப்பதன் மூலம் பாதுகாப்பு அடையப்படுகிறது.


Some of the earliest efforts simply scrambled the letters of the plaintext.

ஆரம்பகால முயற்சிகளில் சில, பிளைன் டெக்ஸ்டின் எழுத்துக்களை எளிமையாகக் குழப்பியது.


இது ஒரு இடமாற்ற சைபர் என்று அழைக்கப்படுகிறது.


Since there are n! permutations of n symbols it may seem impossible for even a computer to do a brute-force search to decode such messages.

n குறியீடுகளின் n! வரிசைமாற்றங்கள் இருப்பதால், இதுபோன்ற செய்திகளை டிகோட் செய்ய ஒரு கணினி கூட ஒரு பிரூட்-போர்ஸ் தேடலைச் செய்வது சாத்தியமற்றதாகத் தோன்றலாம்.


A substitution cypher replaces a symbol by another symbol.

ஒரு மாற்று சைபர் ஒரு குறியீட்டை மற்றொரு குறியீட்டால் மாற்றுகிறது.


Julius Caesar used a very simple form of substitution.

ஜூலியஸ் சீசர் மிகவும் எளிமையான மாற்றத்தைப் பயன்படுத்தினார்.


Cryptanalysis is the name given to unscrambling an intercepted message.

கிரிப்டோஅனாலிசிஸ் என்பது இடைமறிக்கப்பட்ட செய்தியைத் திறப்பதற்கான பெயராகும்.


Data compression is useful and necessary in a variety of applications.

தரவு சுருக்கம் பல்வேறு பயன்பாடுகளில் பயனுள்ளதாகவும் அவசியமானதாகவும் உள்ளது.


These applications can be broadly divided into two groups: transmission and storage.

இந்த பயன்பாடுகளை இரண்டு குழுக்களாகப் பிரிக்கலாம்: பரிமாற்றம் மற்றும் சேமிப்பு.


Compression reduces the number of bits to be transmitted, thus making the transmission process more efficient.

சுருக்கம் அனுப்ப வேண்டிய பிட்களின் எண்ணிக்கையைக் குறைக்கிறது, இதனால் பரிமாற்ற செயல்முறையை மிகவும் திறமையானதாக ஆக்குகிறது.


Storing a file in a compressed form typically requires fewer bits, thus utilizing storage resources more efficiently.

ஒரு கோப்பை சுருக்கப்பட்ட வடிவத்தில் சேமிப்பது பொதுவாக குறைந்த பிட்களைக் கோருகிறது, இதனால் சேமிப்பக வளங்களை மிகவும் திறமையாகப் பயன்படுத்துகிறது.


Data compression can be applied to any kind of data: text, image (such as fax), audio and video.

தரவு சுருக்கத்தை எந்த வகையான தரவிற்கும் பயன்படுத்தலாம்: உரை, படம் (எ.கா., தொலைநகல்), ஆடியோ மற்றும் வீடியோ.


A 1-second video without compression takes around 20 megabytes.

சுருக்கம் இல்லாமல் ஒரு வினாடி வீடியோ சுமார் 20 மெகாபைட் எடுக்கும்.


Impressive gains can be made by compressing video, for instance, because successive frames are very similar to each other in their contents.

வீடியோவை சுருக்கி, உதாரணமாக, அடுத்தடுத்த பிரேம்கள் அவற்றின் உள்ளடக்கங்களில் ஒன்றுக்கொன்று மிகவும் ஒத்திருப்பதால், ஈர்க்கக்கூடிய லாபத்தை அடைய முடியும்.


In fact, real-time video transmission would be impossible without considerable compression.

உண்மையில், கணிசமான சுருக்கம் இல்லாமல் நிகழ்நேர வீடியோ பரிமாற்றம் சாத்தியமற்றதாகிவிடும்.


There are several new applications that generate data at prodigious rates.

அதிக விகிதத்தில் தரவை உருவாக்கும் பல புதிய பயன்பாடுகள் உள்ளன.


Certain earth orbiting satellites create around half a terabyte of data per day.

சில பூமி சுற்றுப்பாதை செயற்கைக்கோள்கள் ஒரு நாளைக்கு சுமார் அரை டெராபைட் தரவை உருவாக்குகின்றன.


Without compression there is no hope of storing such large files in spite of the impressive advances made in storage technologies.

சுருக்கம் இல்லாமல், சேமிப்பக தொழில்நுட்பங்களில் செய்யப்பட்ட அற்புதமான முன்னேற்றங்கள் இருந்தபோதிலும், அத்தகைய பெரிய கோப்புகளை சேமிப்பதில் எந்த நம்பிக்கையும் இல்லை.


இழப்பு மற்றும் இழப்பு இல்லாத சுருக்கம்


Most data types, except text, are compressed in such a way that a very good approximation, but not the exact content, of the original file can be recovered by the receiver.

உரையைத் தவிர, பெரும்பாலான தரவு வகைகள் சுருக்கப்படுகின்றன, இதன் மூலம் அசல் கோப்பின் மிகச் சிறந்த தோராயத்தை, ஆனால் சரியான உள்ளடக்கத்தை அல்ல, பெறுநரால் மீட்டெடுக்க முடியும்.


For instance, even though the human voice can range up to 20kHz in frequency, telephone transmissions retain only up to about 5kHz.

உதாரணமாக, மனித குரல் அதிர்வெண்ணில் 20kHz வரை இருந்தாலும், தொலைபேசி பரிமாற்றங்கள் சுமார் 5kHz வரை மட்டுமே தக்கவைக்கின்றன.


The voice that is reproduced at the receiver’s end is a close approximation to the real thing, but it is not exact.

பெறுநரின் முனையில் மீண்டும் உருவாக்கப்படும் குரல் உண்மையான விஷயத்திற்கு நெருக்கமான தோராயமாக உள்ளது, ஆனால் அது துல்லியமாக இல்லை.


Try listening to your favorite CD played over a telephone line.

தொலைபேசி லைனில் இயங்கும் உங்களுக்குப் பிடித்த சிடியைக் கேட்டுப் பாருங்கள்.


Video transmissions often sacrifice quality for speed of transmission.

வீடியோ பரிமாற்றங்கள் பெரும்பாலும் பரிமாற்றத்தின் வேகத்திற்காக தரத்தை தியாகம் செய்கின்றன.


The type of compression in such situations is called lossy, because the receiver cannot exactly reproduce the original contents.

இத்தகைய சூழ்நிலைகளில் சுருக்கத்தின் வகை இழப்பு என்று அழைக்கப்படுகிறது, ஏனெனில் பெறுநர் அசல் உள்ளடக்கங்களை சரியாக மீண்டும் உருவாக்க முடியாது.


Text transmissions are required to be lossless.

உரை பரிமாற்றங்கள் இழப்பு இல்லாததாக இருக்க வேண்டும்.


It will be a disaster to change even a single symbol in a text file.

உரை கோப்பில் ஒரு சின்னத்தை மாற்றினால் அது பேரழிவாக இருக்கும்.


The final state, where all piles are empty, is a losing state.

எல்லா குவியல்களும் காலியாக இருக்கும் இறுதி நிலை, தோல்வியடையும் நிலையாகும்.


A player in a losing state will definitely lose provided his opponent makes the right moves.

தோல்வியடையும் நிலையில் உள்ள ஒரு வீரர், அவருடைய எதிராளி சரியான நகர்வுகளைச் செய்தால், நிச்சயமாகத் தோற்றுவிடுவார்.


So, one of the players has a winning strategy based on the initial state.

எனவே, ஆரம்ப நிலையைப் பொறுத்து வீரர்களில் ஒருவருக்கு வெற்றி உத்தி உள்ளது.


Of course, either player is allowed to play stupidly and squander a winning position.

நிச்சயமாக, எந்த வீரரும் முட்டாள்தனமாக விளையாடவும், வெற்றி நிலையை வீணடிக்கவும் அனுமதிக்கப்படுகிறார்கள்.


We show that any possible move in a losing state can only lead to a winning state.

தோல்வியடையும் நிலையில் எந்த நகர்வும் வெற்றி நிலைக்கு மட்டுமே வழிவகுக்கும் என்பதை நாங்கள் காட்டுகிறோம்.


A player in a winning state has at least one move to transform the state to losing.

வெற்றி நிலையில் உள்ள ஒரு வீரர், அந்த நிலையைத் தோற்கும் நிலைக்கு மாற்ற குறைந்தபட்சம் ஒரு நகர்வாவது வைத்திருக்க வேண்டும்.


Let the exclusive-or of the remaining piles be s.

மீதமுள்ள குவியல்களின் பிரத்தியேக அல்லது s ஆக இருக்கட்டும்.


Before the move, exclusive-or of all piles was s ⊕ p.

நகர்வுக்கு முன், அனைத்து குவியல்களின் பிரத்தியேக அல்லது s ⊕ p ஆக இருந்தது.


நகர்வுக்குப் பிறகு அது s ⊕ q ஆக உள்ளது.


First, we show that in a losing state, i.e., s ⊕ p = 0, all possible moves establish a winning state, i.e., s ⊕ q ≠ 0.

முதலில், தோல்வியடையும் நிலையில், அதாவது, s ⊕ p = 0, அனைத்து சாத்தியமான நகர்வுகளும் ஒரு வெற்றி நிலையை உருவாக்குகின்றன, அதாவது, s ⊕ q ≠ 0 என்பதை நாங்கள் காட்டுகிறோம்.


Now, we show that there is a move in the winning state to take it to losing state.

இப்போது, வெற்றி நிலையில் அதைத் தோல்வியடையும் நிலைக்குக் கொண்டு செல்வதற்கான ஒரு நகர்வு உள்ளது என்பதை நாங்கள் காட்டுகிறோம்.


The winning move is to replace x by x ⊕ u.

வெற்றி நகர்வு x ஐ x ⊕ u ஆல் மாற்றுவதாகும்.


We show that (1) x ⊕ u < x, and (2) the exclusive-or of the resulting set of piles is 0, i.e., the state after the move is a losing state.

நாம் (1) x ⊕ u < x என்றும், (2) இதன் விளைவாகக் கிடைக்கும் குவியல்களின் பிரத்தியேக அல்லது 0 என்றும் காட்டுகிறோம், அதாவது, நகர்வுக்குப் பிறகு நிலை ஒரு தோல்வியடையும் நிலையாகும்.


The problem in secure communication is for a sender to send a message to a receiver so that no eavesdropper can read the message during transmission.

பாதுகாப்பான தகவல்தொடர்பில் உள்ள சிக்கல் என்னவென்றால், அனுப்புநர் ஒரு செய்தியைப் பெறுநருக்கு அனுப்புவதாகும், இதனால் எந்த ஒட்டு கேட்பவரும் பரிமாற்றத்தின் போது செய்தியைப் படிக்க முடியாது.


In most cases, the sender and the receiver agree on a transmission protocol; the sender encrypts the message in such a fashion that only the receiver can decrypt it.

பெரும்பாலான சந்தர்ப்பங்களில், அனுப்புநரும் பெறுநரும் ஒரு பரிமாற்ற நெறிமுறையை ஒப்புக்கொள்கிறார்கள்; அனுப்புநர் செய்தியை குறியாக்கம் செய்கிறார், இதனால் பெறுநரால் மட்டுமே அதை டிகோட் செய்ய முடியும்.


The sender first converts the message to be sent to a bit string, by replacing each symbol of the alphabet by its ascii representation, for instance.

அனுப்புநர் முதலில் அனுப்ப வேண்டிய செய்தியை ஒரு பிட் சரமாக மாற்றுகிறார், எடுத்துக்காட்டாக, எழுத்துக்களின் ஒவ்வொரு குறியீட்டையும் அதன் ascii பிரதிநிதித்துவத்துடன் மாற்றுகிறார்.


For encryption, the sender and the receiver agree on a key k, which is a bit string of the same length as the block.

குறியாக்கத்திற்காக, அனுப்புநரும் பெறுநரும் ஒரு முக்கிய k ஐ ஒப்புக்கொள்கிறார்கள், இது தொகுதியின் அதே நீளத்தின் பிட் சரமாகும்.


The receiver, on receiving y, computes y ⊕ k which is (x ⊕ k) ⊕ k, i.e., x, the original message.

பெறுநர், y ஐப் பெற்றவுடன், y ⊕ k ஐக் கணக்கிடுகிறார், இது (x ⊕ k) ⊕ k, அதாவது, x, அசல் செய்தி.


An eavesdropper can only see y which appears as pure gibberish.

ஒரு ஒட்டு கேட்பவர் y ஐ மட்டுமே பார்க்க முடியும், இது முற்றிலும் புரியாததாகத் தோன்றுகிறது.


This communication scheme is simple to program; in fact, encryption and decryption have the same program.

இந்த தகவல் தொடர்பு திட்டம் நிரல் செய்ய எளிதானது; உண்மையில், குறியாக்கம் மற்றும் டிகோடிங் ஒரே நிரலைக் கொண்டுள்ளன.


The sender scans the text from left to right identifying certain strings that it inserts into a dictionary.

அனுப்புனர் உரையை இடமிருந்து வலமாக ஸ்கேன் செய்து, சில சரங்களை அடையாளம் கண்டு அவற்றை அகராதியில் செருகுகிறார்.


Lempel-Ziv coding does not require the frequencies to be known a priori.

லெம்பெல்-சிவ் குறியீட்டு முறைக்கு அதிர்வெண்கள் முன்னரே தெரிந்திருக்க வேண்டிய அவசியமில்லை.


The receiver recreates the string taa, by looking up the word with index 3 and appending a to it.

பெறுநர் குறியீடு 3 கொண்ட வார்த்தையை எடுத்துக்கொண்டு, அதனுடன் 'a' ஐச் சேர்த்து, 'taa' சரத்தை மீண்டும் உருவாக்குகிறார்.


Initially, the dictionary has a single word, the empty string, <> , as its only (0th) entry.

ஆரம்பத்தில், அகராதியில் ஒரே ஒரு வார்த்தை மட்டுமே உள்ளது, அது வெற்று சரமாகும், <> , இதுவே அதன் ஒரே (0வது) உள்ளீடாக இருக்கும்.


To ensure that the sender can always find a word which is not in the dictionary, assume that the end of the file, written as #, occurs nowhere else in the string.

அனுப்புனர் எப்போதும் அகராதியில் இல்லாத ஒரு வார்த்தையைக் கண்டறிய முடியும் என்பதை உறுதிப்படுத்த, கோப்பின் முடிவு, # என எழுதப்பட்டது, சரத்தில் வேறு எங்கும் இல்லை என்று வைத்துக்கொள்வோம்.


It should be clear that the receiver can update the dictionary and recreate the text from the given transmissions.

பெறுநர் அகராதியை புதுப்பிக்க முடியும் மற்றும் கொடுக்கப்பட்ட பரிமாற்றங்களிலிருந்து உரையை மீண்டும் உருவாக்க முடியும் என்பது தெளிவாக இருக்க வேண்டும்.


But for longer files with much redundancy, this scheme achieves excellent results.

ஆனால் அதிக அளவு மிகைப்படுத்தல் கொண்ட நீண்ட கோப்புகளுக்கு, இந்த திட்டம் சிறந்த முடிவுகளைத் தருகிறது.


Lempel-Ziv coding is asymptotically optimal, i.e., as the text length tends to infinity, the compression tends to the optimal value predicted by information theory.

லெம்பெல்-சிவ் குறியீட்டு முறை வரம்பில் உகந்ததாக உள்ளது, அதாவது, உரையின் நீளம் முடிவிலியை நோக்கிச் செல்லும்போது, சுருக்கம் தகவல் கோட்பாடு கணித்த உகந்த மதிப்பிற்குச் செல்கிறது.


In practice, the dictionary is limited to a fixed size, like 4096 (so that each index can be encoded in 12 bits).

நடைமுறையில், அகராதி 4096 போன்ற ஒரு நிலையான அளவிற்கு மட்டுமே கட்டுப்படுத்தப்படுகிறது (இதனால் ஒவ்வொரு குறியீட்டையும் 12 பிட்களில் குறியிட முடியும்).


Beyond that point, the transmissions continue in the same manner, but the dictionary is not updated.

அந்தப் புள்ளிக்கு அப்பால், பரிமாற்றங்கள் அதே முறையில் தொடர்கின்றன, ஆனால் அகராதி புதுப்பிக்கப்படவில்லை.


Also, in practical implementations, the dictionary is initially populated by all the symbols of the alphabet.

மேலும், நடைமுறை பயன்பாடுகளில், அகராதி ஆரம்பத்தில் எழுத்துக்களின் அனைத்து சின்னங்களாலும் நிரப்பப்படுகிறது.


There are a number of variations of the Lempel-Ziv algorithm, all having the prefix LZ.

லெம்பெல்-சிவ் வழிமுறையின் பல வகைகள் உள்ளன, அவை அனைத்தும் LZ என்ற முன்னொட்டைக் கொண்டுள்ளன.


Many popular compression programs —Unix utility “compress”, “gzip”, Windows “Winzip”— are based on some variant of the Lempel-Ziv algorithm.

பல பிரபலமான சுருக்க நிரல்கள் —Unix பயன்பாடு “compress”, “gzip”, Windows “Winzip”— லெம்பெல்-சிவ் வழிமுறையின் சில வகைகளை அடிப்படையாகக் கொண்டவை.


We develop a data structure to implement the dictionary and the two operations on it.

அகராதி மற்றும் அதில் உள்ள இரண்டு செயல்பாடுகளைச் செயல்படுத்த ஒரு தரவு கட்டமைப்பை உருவாக்குகிறோம்.


The data structure is a special kind of tree (sometimes called a “trie”).

தரவு கட்டமைப்பு ஒரு சிறப்பு வகையான மரம் (சில நேரங்களில் “ட்ரை” என்று அழைக்கப்படுகிறது).


Associated with each node of the tree is a word of the dictionary and its index.

மரத்தின் ஒவ்வொரு முனையுடனும் அகராதியின் ஒரு வார்த்தையும் அதன் குறியீடும் தொடர்புடையவை.


The root node has the word <> (empty string) and index 0 associated with it.

ரூட் முனை <> (வெற்று சரத்தை) கொண்டுள்ளது மற்றும் குறியீடு 0 உடன் தொடர்புடையது.


Given a text string, the sender starts matching its symbols against the symbols at the branches, starting at the root node.

ஒரு உரை சரத்தை வழங்கினால், அனுப்புனர் அதன் சின்னங்களை கிளைகளில் உள்ள சின்னங்களுடன் பொருத்துகிறார், ரூட் முனையிலிருந்து தொடங்குகிறார்.


The receiver does not need to maintain the tree.

பெறுநர் மரத்தை பராமரிக்க வேண்டியதில்லை.


The tree shown in Figure 1.6 results from the string taccagtaccagtaccacta#.

படம் 1.6 இல் காட்டப்பட்டுள்ள மரம் taccagtaccagtaccacta# என்ற சரத்திலிருந்து விளைகிறது.


Alice sends a public key to Bob which Bob uses to send her a secret.

ஆலிஸ் ஒரு பொது விசையை பாபிடம் அனுப்புகிறார், அதை பாப் அவளுக்கு ஒரு ரகசியத்தை அனுப்ப பயன்படுத்துகிறார்.


They can then employ the secret for further communications.

பின்னர் அவர்கள் ரகசியத்தை மேலும் தொடர்புகளுக்குப் பயன்படுத்தலாம்.


Here, pis a prime number; typically pis large (a 300 bit number will do fine for most applications).

இங்கே, பி ஒரு முதன்மை எண்; பொதுவாக பி பெரியது (300 பிட் எண் பெரும்பாலான பயன்பாடுகளுக்கு நன்றாக இருக்கும்).


Alice and Bob privately choose integers a and b which are less than p.

ஆலிஸும் பாபும் தனிப்பட்ட முறையில் p ஐ விடக் குறைவான முழு எண்களை a மற்றும் b ஐத் தேர்ந்தெடுக்கிறார்கள்.


Alice sends g a mod p and Bob sends g b mod p.

ஆலிஸ் g a mod p ஐ அனுப்புகிறார், பாப் g b mod p ஐ அனுப்புகிறார்.


Then Alice computes (g b mod p) a mod p. This quantity is g ab mod p.

பின்னர் ஆலிஸ் (g b mod p) a mod p ஐ கணக்கிடுகிறார். இந்த அளவு g ab mod p ஆகும்.


Similarly, Bob computes (g a mod p) b mod p = g ab mod p.

அதேபோல், பாப் (g a mod p) b mod p = g ab mod p ஐ கணக்கிடுகிறார்.


They both have g ab mod p, and they settle on that as the secret key.

அவர்கள் இருவருக்கும் g ab mod p உள்ளது, மேலும் அதை ரகசிய விசையாக ஏற்றுக்கொள்கிறார்கள்.


உதாரணமாக, g = 3 மற்றும் p = 17 ஆக இருக்கட்டும்.


Verify that g is a 16th primitive root of 1.

g என்பது 1 இன் 16 வது ஆதி மூலமா என்பதை சரிபார்க்கவும்.


Let Alice choose a = 5 and Bob choose b = 9.

ஆலிஸ் a = 5 என்றும், பாப் b = 9 என்றும் தேர்ந்தெடுக்கட்டும்.


Then, Alice and Bob send to each other 3 5 mod 17 = 5 and 3 9 mod 17 = 14, respectively.

பின்னர், ஆலிஸும் பாபும் ஒருவருக்கொருவர் 3 5 mod 17 = 5 மற்றும் 3 9 mod 17 = 14 ஐ அனுப்புகிறார்கள்.


Next, Alice computes 14 5 mod 17 and Bob computes 5 9 mod 17, both of which are 12.

அடுத்து, ஆலிஸ் 14 5 mod 17 ஐ கணக்கிடுகிறார், பாப் 5 9 mod 17 ஐ கணக்கிடுகிறார், இவை இரண்டும் 12 ஆகும்.


Each of them now knows 12 as the secret key.

அவர்கள் ஒவ்வொருவரும் இப்போது 12 ஐ ரகசிய விசையாக அறிவார்கள்.


We have to choose a large prime number p and a positive integer g which is a (p−1)th root of 1.

நாம் ஒரு பெரிய முதன்மை எண்ணான p மற்றும் ஒரு நேர்மறை முழு எண் g ஐத் தேர்ந்தெடுக்க வேண்டும், இது (p−1)th ரூட் 1 ஆகும்.


From the description of the protocol, we don’t really need that g be a (p−1)th root of 1.

நெறிமுறையின் விளக்கத்திலிருந்து, g என்பது (p−1)th ரூட் 1 ஆக இருக்க வேண்டும் என்று உண்மையில் தேவையில்லை.


We look for a g such that g 2 mod p ≠ 1; then g k mod p ≠ 1, for all k, 1 ≤ k < q.

g 2 mod p ≠ 1 ஆக இருக்கும் ஒரு g ஐ நாங்கள் தேடுகிறோம்; பின்னர் g k mod p ≠ 1, அனைத்து k க்கும், 1 ≤ k < q.


Usually, this is a very short computation.

பொதுவாக, இது மிகக் குறுகிய கணக்கீடாகும்.


The task of Eve is to compute a or b given g, p, g a mod p and g b mod p.

ஈவ்வின் பணி g, p, g a mod p மற்றும் g b mod p ஆகியவற்றைக் கொண்டு a அல்லது b ஐக் கணக்கிடுவதாகும்.


This is known as the Discrete Logarithm Problem, for which there is no known efficient algorithm.

இது தனித்த மடக்கை சிக்கல் என்று அழைக்கப்படுகிறது, இதற்கு எந்த அறியப்பட்ட திறமையான வழிமுறையும் இல்லை.


Variables u, v, p, x and y are positive integers.

u, v, p, x மற்றும் y ஆகியவை நேர்மறை முழு எண்களாகும்.


For all n, n ≥ 0, x mod p ≡ y x^n mod p ≡ y^n

எல்லா n க்கும், n ≥ 0, x mod p ≡ y x^n mod p ≡ y^n


Let e be any expression over integers that has only addition, subtraction, multiplication and exponentiation as its operators.

e என்பது கூட்டல், கழித்தல், பெருக்கல் மற்றும் அடுக்குக்குறி போன்ற கணிதச் செயல்பாடுகளைக் கொண்ட முழு எண்களின் வெளிப்பாடு ஆகும்.


Relatively Prime Positive integers x and y are relatively prime iff gcd(x, y) = 1.

சார்பு பகா எண்கள் x மற்றும் y ஆகியவை சார்பு பகா எண்களாகும், எப்பொழுது என்றால் gcd(x, y) = 1.


For p and q relatively prime, (u mod p ≡ v ∧ u mod q ≡ v) ≡ (u mod p×q ≡ v)

p மற்றும் q சார்பு பகா எண்களாக இருந்தால், (u mod p ≡ v ∧ u mod q ≡ v) ≡ (u mod p×q ≡ v)


Show that the algorithm terminates, and that α: {(a×x+b×y=u) ∧ (c×x+d×y=v)} is a loop invariant.

அல்காரிதம் எவ்வாறு முடிகிறது என்பதையும், α: {(a×x+b×y=u) ∧ (c×x+d×y=v)} ஒரு சுழற்சி மாறிலி என்பதையும் காட்டு.


இரண்டு பெரிய பகா எண்களைத் தேர்ந்தெடுங்கள் p மற்றும் q, p ≠ q.


Let n = p × q. And, define φ(n) = (p−1) × (q−1).

n = p × q என வைத்துக்கொள்வோம். மேலும், φ(n) = (p−1) × (q−1) என வரையறுக்கவும்.


Choose integers d and e (d is for decryption and e for encryption) such that 1. 1 ≤ d < n, 1 ≤ e < n, 2. both d and e are relatively prime to φ(n), and 3. d × e mod φ(n) ≡ 1.

d மற்றும் e ஆகிய முழு எண்களைத் தேர்ந்தெடுக்கவும் (d என்பது டிகிரிப்ஷனுக்கும், e என்பது என்கிரிப்ஷனுக்கும்) 1. 1 ≤ d < n, 1 ≤ e < n, 2. d மற்றும் e இரண்டும் φ(n) உடன் சார்பு பகா எண்களாக இருக்க வேண்டும், மற்றும் 3. d × e mod φ(n) ≡ 1.


It is customary to choose e, the encryption key, to be a small value (like 3 or 5) which is below n and relatively prime to φ(n).

e, என்கிரிப்ஷன் விசையை, n ஐ விடக் குறைவாகவும், φ(n) உடன் சார்பு பகா எண்ணாகவும் இருக்கும் சிறிய மதிப்பாக (3 அல்லது 5 போன்றவை) தேர்ந்தெடுப்பது வழக்கம்.


To send message M to a principal whose public key is (e, n) and 0 ≤ M < n, send M′ where M′ = (M^e mod n).

(e, n) என்ற பொது விசையைக் கொண்ட ஒருவருக்கு செய்தி M ஐ அனுப்ப, 0 ≤ M < n என்றால், M′ ஐ அனுப்பவும், இங்கு M′ = (M^e mod n).


Let us represent each letter of the alphabet by two digits, with white space = 00 a = 01 b = 02, etc.

வெள்ளை இடைவெளி = 00, a = 01, b = 02, போன்ற எழுத்துக்களை இரண்டு இலக்கங்களால் குறிப்போம்.


There is an efficient way to raise a number to a given exponent.

ஒரு எண்ணை ஒரு குறிப்பிட்ட அடுக்குக்கு உயர்த்த ஒரு திறமையான வழி உள்ளது.


The multiplication strategy depends on the binary representation of the exponent.

பெருக்கல் உத்தி அடுக்கின் இரும முறைமையைச் சார்ந்தது.


The following algorithm implements this strategy.

பின்வரும் அல்காரிதம் இந்த உத்தியை செயல்படுத்துகிறது.


0201 ஐ 2710 ஆகவும், 0400 ஐ 0017 ஆகவும் என்கிரிப்ட் செய்கிறோம்.


On receiving an encrypted message M′, 0 ≤ M′ < n, Bob, whose private key is (d, n), computes M′′ as follows.

ஒரு என்கிரிப்ட் செய்யப்பட்ட செய்தியைப் பெற்ற பிறகு M′, 0 ≤ M′ < n, பாப், யாருடைய தனிப்பட்ட விசை (d, n) ஆக உள்ளதோ, M′′ ஐ பின்வருமாறு கணக்கிடுகிறார்.


M′′ = M என்பதை கீழே காட்டுகிறோம்.


The question of breaking RSA amounts to extracting the plaintext from the ciphertext.

RSA ஐ உடைப்பதற்கான கேள்வி, சைப்ர்டெக்ஸ்டில் இருந்து பிளைன்டெக்ஸ்ட்டை பிரித்தெடுப்பதாகும்.


Suppose Bob receives a message from someone claiming to be Alice; how can he be sure that Alice sent the message?

அலிஸ் என்று கூறிக்கொள்பவரிடமிருந்து பாப் ஒரு செய்தியைப் பெறுகிறார் என்றால், அந்த செய்தியை அலிஸ் அனுப்பினார் என்பதை அவர் எப்படி உறுதிப்படுத்த முடியும்?


இயந்திரம் எப்போதும் ஜி-யில் இருக்கும்.


We will simplify Figure 4.21 to Figure 4.22.

படம் 4.21-ஐ படம் 4.22-ஆக எளிதாக்குவோம்.


How do we construct a machine to recognize concatenation?

தொடர்பை அங்கீகரிக்க ஒரு இயந்திரத்தை எவ்வாறு உருவாக்குவது?


c* ஐ ஏற்க வேண்டும் என்று வைத்துக்கொள்வோம்.


இயந்திரம் படம் 4.24 இல் காட்டப்பட்டுள்ளது.


Next, let us construct a machine that accepts bc*|cb*.

அடுத்து, bc*|cb* ஐ ஏற்கும் ஒரு இயந்திரத்தை உருவாக்குவோம்.


Regular expressions have a syntax in which a few characters are special constructs.

வழக்கமான வெளிப்பாடுகள் ஒரு தொடரியலைக் கொண்டுள்ளன, அதில் சில எழுத்துக்கள் சிறப்பு கட்டமைப்புகளாகும்.


An ordinary character is a simple regular expression which matches that same character and nothing else.

ஒரு சாதாரண எழுத்து என்பது ஒரு எளிய வழக்கமான வெளிப்பாடு ஆகும், இது அதே எழுத்தை மட்டுமே பொருத்துகிறது, வேறொன்றையும் இல்லை.


For example, ‘f’ is not a special character, so it is ordinary, and therefore ‘f’ is a regular expression that matches the string ‘f’ and no other string.

உதாரணமாக, ‘f’ ஒரு சிறப்பு எழுத்து அல்ல, எனவே அது சாதாரணமானது, ஆகையால் ‘f’ என்பது ‘f’ என்ற சரத்தை மட்டும் பொருத்தும் ஒரு வழக்கமான வெளிப்பாடு ஆகும், வேறு எந்த சரத்தையும் இல்லை.


Any two regular expressions A and B can be concatenated.

எந்த இரண்டு வழக்கமான வெளிப்பாடுகளையும் A மற்றும் B இணைக்க முடியும்.


The result is a regular expression which matches a string if A matches some amount of the beginning of that string and B matches the rest of the string.

A ஆனது அந்த சரத்தின் ஆரம்பத்தின் ஒரு பகுதியை பொருத்தினாலும், B ஆனது சரத்தின் மீதமுள்ள பகுதியை பொருத்தினாலும், இதன் விளைவாக ஒரு வழக்கமான வெளிப்பாடு ஒரு சரத்தை பொருத்தும்.


To do something nontrivial, you need to use one of the special characters.

சாதாரணமற்ற ஒன்றைச் செய்ய, நீங்கள் சிறப்பு எழுத்துகளில் ஒன்றைப் பயன்படுத்த வேண்டும்.


‘.’ is a special character that matches any single character except a newline.

‘.’ என்பது ஒரு சிறப்பு எழுத்து, இது ஒரு புதிய வரி தவிர வேறு எந்த ஒற்றை எழுத்தையும் பொருத்தும்.


‘*’ is not a construct by itself; it is a postfix operator, which means to match the preceding regular expression repetitively as many times as possible.

‘*’ என்பது ஒரு கட்டமைப்பாக இல்லை; இது ஒரு பின்நிலை ஆபரேட்டர், அதாவது முந்தைய வழக்கமான வெளிப்பாட்டை முடிந்தவரை பல முறை மீண்டும் மீண்டும் பொருத்துகிறது.


The matcher processes a ‘*’ construct by matching, immediately, as many repetitions as can be found.

பொருத்துபவர் ‘*’ கட்டமைப்பை உடனடியாகப் பொருத்துவதன் மூலம் செயலாக்குகிறார், எத்தனை மறுபடியும் கண்டுபிடிக்க முடியுமோ அத்தனை முறை.


For example, matching ‘ca*ar’ against the string ‘caaar’, the ‘a*’ first tries to match all three ‘a’s; but the rest of the pattern is ‘ar’ and there is only ‘r’ left to match, so this try fails.

உதாரணமாக, ‘ca*ar’ ஐ ‘caaar’ என்ற சரத்துடன் பொருத்துகையில், ‘a*’ முதலில் மூன்று ‘a’ களையும் பொருத்த முயற்சிக்கிறது; ஆனால் மீதமுள்ள முறை ‘ar’ மற்றும் பொருத்த ‘r’ மட்டுமே உள்ளது, எனவே இந்த முயற்சி தோல்வியடைகிறது.


‘+’ is a postfix character, similar to ‘*’ except that it must match the preceding expression at least once.

‘+’ என்பது ஒரு பின்நிலை எழுத்து, ‘*’ போன்றது, முந்தைய வெளிப்பாட்டை குறைந்தபட்சம் ஒரு முறையாவது பொருத்த வேண்டும்.


‘?’ is a postfix character, similar to ‘*’ except that it can match the preceding expression either once or not at all.

‘?’ என்பது ஒரு பின்நிலை எழுத்து, ‘*’ போன்றது, முந்தைய வெளிப்பாட்டை ஒரு முறையோ அல்லது அறவே இல்லாமலோ பொருத்தலாம்.


‘[ ... ]’ is a character set, which begins with ‘[’ and is terminated by a ‘]’.

‘[ ... ]’ என்பது ஒரு எழுத்துத் தொகுப்பு, இது ‘[’ உடன் தொடங்கி ‘]’ உடன் முடிவடைகிறது.


You can also include character ranges a character set, by writing two characters with a ‘-’ between them.

நீங்கள் எழுத்து வரம்புகளையும் ஒரு எழுத்துத் தொகுப்பில் சேர்க்கலாம், இரண்டு எழுத்துக்களை எழுதி, அவற்றின் இடையில் ‘-’ ஐப் பயன்படுத்துவதன் மூலம்.


initial state holds for the empty string, and (3) for each transition do the following verification: suppose the transition is labeledsand it is from a state annotated withbto one withc; then, show that ifbholds for any string x, thencholds forxs.

ஆரம்ப நிலை வெற்று சரத்திற்குப் பொருந்தும், மேலும் (3) ஒவ்வொரு மாற்றத்திற்கும் பின்வரும் சரிபார்ப்பைச் செய்யுங்கள்: மாற்றம் s எனக் குறிக்கப்பட்டால், அது b எனக் குறிக்கப்பட்ட நிலையிலிருந்து c எனக் குறிக்கப்பட்ட நிலைக்குச் சென்றால், எந்தவொரு சரத்திற்கும் b பொருந்தினால், xs க்கு c பொருந்தும் என்பதைக் காட்டுங்கள்.


For the machine in Figure 4.12, we have already done step (1).

படம் 4.12 இல் உள்ள இயந்திரத்திற்கு, நாம் ஏற்கனவே படி (1) செய்துவிட்டோம்.


For step (2), we have to show that the empty string satisfiesp∧q, that is, the empty string has an even number of 0s and 1s, which clearly holds.

படி (2) க்கு, வெற்று சரமானது p∧q ஐ நிறைவு செய்கிறது என்பதை நாம் காட்ட வேண்டும், அதாவது, வெற்று சரத்தில் சம எண்ணிக்கையிலான 0 களும் 1 களும் உள்ளன, இது தெளிவாகப் பொருந்தும்.


For step (3), we have to verify all eight transitions, as shown in Table 4.8.

படி (3) க்கு, அட்டவணை 4.8 இல் காட்டப்பட்டுள்ளபடி, எட்டு மாற்றங்களையும் சரிபார்க்க வேண்டும்.


For example, it is straightforward to verify the transition from A to B by considering an arbitrary stringxwith an even number of 0s and 1s (p∧q) and proving thatx0 has odd number of 0s and even number of 1s (¬p∧q).

உதாரணமாக, A இலிருந்து B க்கு மாறும் மாற்றத்தை சரிபார்ப்பது எளிது, ஒரு தன்னிச்சையான சரத்தை x உடன் சம எண்ணிக்கையிலான 0 கள் மற்றும் 1 கள் (p∧q) எனக் கருதி, x0 ஆனது ஒற்றைப்படை எண்ணிக்கையிலான 0 களையும், இரட்டைப்படை எண்ணிக்கையிலான 1 களையும் (¬p∧q) கொண்டுள்ளது என்பதை நிரூபிப்பதன் மூலம்.


Why Does the Verification Procedure Work?

சரிபார்ப்பு நடைமுறை ஏன் வேலை செய்கிறது?


It seems that we are using some sort of circular argument, but that is not so.

நாம் ஒரு வட்ட வாதத்தைப் பயன்படுத்துகிறோம் என்று தோன்றுகிறது, ஆனால் அது அப்படி இல்லை.


In order to convince yourself 4.2. FINITE STATE MACHINE83 that the argument is not circular, construct a proof using induction.

வாதமானது வட்டமானது அல்ல என்பதை நீங்களே நம்புவதற்கு, தூண்டலைப் பயன்படுத்தி ஒரு ஆதாரத்தை உருவாக்குங்கள்.


The the- orem we need to prove is as follows: after processing any stringx, the machine state is A, B, C or D iffxsatisfiesp∧q,¬p∧q,¬p∧¬qorp∧¬q, respectively.

நாம் நிரூபிக்க வேண்டிய தேற்றம் பின்வருமாறு: எந்தவொரு சரத்தையும் x செயல்படுத்திய பிறகு, இயந்திர நிலை A, B, C அல்லது D ஆக இருக்கும், iff ஆனது p∧q, ¬p∧q, ¬p∧¬q அல்லது p∧¬q ஐ முறையே திருப்திப்படுத்துகிறது.


The proof of this statement is by induction on the length ofx.

இந்த கூற்றின் ஆதாரம் x இன் நீளத்தின் மீது தூண்டல் மூலம் உள்ளது.


For|x|= 0:xis an empty string andp∧qholds for it.

|x|= 0: x என்பது ஒரு வெற்று சரமாகும், மேலும் p∧q அதற்குப் பொருந்தும்.


The machine state is A, so the theorem holds.

இயந்திர நிலை A, எனவே தேற்றம் பொருந்தும்.


For|x|=n+ 1,n≥0: use the induction hypothesis and the proofs from Table 4.8.

|x|=n+ 1,n≥0: தூண்டல் கருதுகோளையும், அட்டவணை 4.8 இல் உள்ள ஆதாரங்களையும் பயன்படுத்தவும்.


அத்தகைய இயந்திரங்கள் ஏற்பிகள் என்று அழைக்கப்படுகின்றன.


Now, we will en- hance the machine so that it also produces a string as output; such machines are calledtransducers.

இப்போது, இயந்திரத்தை மேம்படுத்துவோம், இதனால் அது வெளியீடாக ஒரு சரத்தையும் உருவாக்குகிறது; அத்தகைய இயந்திரங்கள் டிரான்ஸ்ட்யூசர்கள் என்று அழைக்கப்படுகின்றன.


Transducers provide powerful string processing mechanism.

டிரான்ஸ்ட்யூசர்கள் சக்திவாய்ந்த சர செயலாக்க வழிமுறையை வழங்குகின்றன.


Typically, acceptance or rejection of the input string is of no particular im- portance in transducers; only the construction of the appropriate output string matters.

பொதுவாக, உள்ளீட்டு சரத்தை ஏற்றுக்கொள்வது அல்லது நிராகரிப்பது டிரான்ஸ்ட்யூசர்களில் எந்த முக்கியத்துவமும் இல்லை; பொருத்தமான வெளியீட்டு சரத்தை உருவாக்குவது மட்டுமே முக்கியம்.


Pictorially, we will depict a transition as shown in Figure 4.13.

பட ரீதியாக, படம் 4.13 இல் காட்டப்பட்டுள்ளபடி ஒரு மாற்றத்தை சித்தரிப்போம்.


It denotes that on reading symbols, the machine transits from A to B and outputs string t.

சின்னங்களைப் படிக்கும்போது, இயந்திரம் A இலிருந்து B க்கு மாறுகிறது மற்றும் சரத்தை வெளியிடுகிறது என்பதைக் குறிக்கிறது.


The output alphabet of the machine —over whichtis a string— may differ from its input alphabet.

இயந்திரத்தின் வெளியீட்டு எழுத்துக்கள் - இதில் t ஒரு சரமாக உள்ளது - அதன் உள்ளீட்டு எழுத்துக்களிலிருந்து வேறுபடலாம்.


The expression isa=s+pand we should resume computation of its outer expression as if we have seen the constanta.

isa=s+p என்ற வெளிப்பாட்டை நாம் ஒரு மாறிலி a ஐப் பார்த்தது போல் அதன் வெளிப்புற வெளிப்பாட்டின் கணக்கீட்டைத் தொடர வேண்டும்.


We retrieve the top pair of values from the stack, assign them tosandp, and simulate the transition that handles a constant, i.e., we setp:=p×a.

நாம் அடுக்குக்குறியிலிருந்து மேல் ஜோடி மதிப்புகளை மீட்டெடுக்கிறோம், அவற்றை s மற்றும் p க்கு ஒதுக்குகிறோம், மேலும் ஒரு மாறிலியைக் கையாளும் மாற்றத்தை உருவகப்படுத்துகிறோம், அதாவது p:=p×a என அமைக்கிறோம்.


We store the length of the stack inn, incrementing it on encountering a “(” and decrementing it for a “)”.

அடுக்குக்குறியின் நீளத்தை n இல் சேமிக்கிறோம், '(' ஐக் கண்டால் அதை அதிகரிக்கிறோம், ')' க்கு அதை குறைக்கிறோம்.


A “)” is accepted only whenn >0 and “#” whenn= 0.

n > 0 ஆக இருக்கும்போது மட்டுமே ‘)’ ஏற்றுக்கொள்ளப்படும், மேலும் n = 0 ஆக இருக்கும்போது ‘#’ ஏற்றுக்கொள்ளப்படும்.


Computes value of arithmetic expression Here,αandβare the following program fragments.

கணித வெளிப்பாட்டின் மதிப்பை கணக்கிடுகிறது. இங்கு, α மற்றும் β ஆகியவை பின்வரும் நிரல் துண்டுகள் ஆகும்.


Exercise 49 Run the machine of Figure 4.34 on input string 3 + (4×(2×6 + 8)×3) + 7# and show the values of the variables (including contents of the stack) at each step.

பயிற்சி 49: படம் 4.34 இன் இயந்திரத்தை உள்ளீட்டு சரத்தில் இயக்குக: 3 + (4×(2×6 + 8)×3) + 7# மற்றும் ஒவ்வொரு படியிலும் மாறிகளின் மதிப்புகளைக் காட்டு (அடுக்குக்குறியின் உள்ளடக்கங்கள் உட்பட).


Choose several strings that are syntactically incorrect, and run the machine on each of them.

தவறான சொற்றொடரியல் கொண்ட பல சரங்களை தேர்ந்தெடுத்து, ஒவ்வொன்றிலும் இயந்திரத்தை இயக்குக.


Exercise 50 (Research) Would it be simpler to specify the machine in Figure 4.34 if we could call a machine recursively?

பயிற்சி 50 (ஆராய்ச்சி) நாம் ஒரு இயந்திரத்தை மீண்டும் அழைக்க முடிந்தால், படம் 4.34 இல் உள்ள இயந்திரத்தை குறிப்பிடுவது எளிதாக இருக்குமா?


Explore the possibility of adding recursion to finite state machines.

வரையறுக்கப்பட்ட நிலை இயந்திரங்களுக்கு மறுபடியும் சேர்ப்பதற்கான சாத்தியக்கூறுகளை ஆராயுங்கள்.


Enhanced finite state machines are often used to specify and design event-based systems.

மேம்படுத்தப்பட்ட வரையறுக்கப்பட்ட நிலை இயந்திரங்கள் நிகழ்வு அடிப்படையிலான அமைப்புகளைக் குறிப்பிடவும் வடிவமைக்கவும் அடிக்கடி பயன்படுத்தப்படுகின்றன.


An event happens in the external world and the machine has to react to the event.

ஒரு நிகழ்வு வெளிப்புற உலகில் நிகழ்கிறது, மேலும் இயந்திரம் அந்த நிகழ்வுக்கு வினைபுரிய வேண்டும்.


Consider the dome light in a car that is either “on” or “off”.

ஒரு காரில் உள்ள கூரை விளக்கை எடுத்துக் கொள்ளுங்கள், அது “ஆன்” அல்லது “ஆஃப்” நிலையில் இருக்கும்.


ஆரம்பத்தில், விளக்கு அணைக்கப்படும்.


The light comes on if a switch is pressed (denote the switch press by eventsw) or if the door is opened (denote bydoor).

ஒரு சுவிட்சை அழுத்தினால் விளக்கு எரிகிறது (சுவிட்சை அழுத்துவதை eventsw மூலம் குறிக்கவும்) அல்லது கதவு திறந்தால் (door மூலம் குறிக்கவும்).


The light goes off if the switch is pressed again (i.e., eventsw), the door is closed (denote bydoor ′ ) or 5 minutes elapse with the light being on (denote this time-out event bytmout).

சுவிட்சை மீண்டும் அழுத்தினால் (அதாவது, eventsw), கதவு மூடப்பட்டால் (door ′ மூலம் குறிக்கவும்) அல்லது விளக்கு எரிந்து கொண்டிருக்கும்போது 5 நிமிடங்கள் முடிந்தால் (இந்த நேர-அவுட் நிகழ்வை tmout மூலம் குறிக்கவும்) விளக்கு அணைக்கப்படும்.


The example just described denotes an elementary event-based system.

விவரிக்கப்பட்ட எடுத்துக்காட்டு ஒரு ஆரம்ப நிகழ்வு அடிப்படையிலான அமைப்பைக் குறிக்கிறது.


The events aresw,door,door ′ , andtmout.

நிகழ்வுகள் aresw, door, door ′, மற்றும் tmout ஆகும்.


The designer has no control over if or when the events happen (the time out event is special; it is guaranteed to happen at the designated time).

நிகழ்வுகள் எப்போது நிகழ்கின்றன என்பதை வடிவமைப்பாளர் கட்டுப்படுத்த முடியாது (நேர-அவுட் நிகழ்வு சிறப்பு; அது நியமிக்கப்பட்ட நேரத்தில் நிகழும் என்று உத்தரவாதம் அளிக்கப்படுகிறது).


He has to design a system that enters the correct state and carries out the appropriate actions when an event happens.

ஒரு நிகழ்வு நிகழும்போது சரியான நிலையில் நுழைந்து பொருத்தமான செயல்களைச் செய்யும் ஒரு அமைப்பை அவர் வடிவமைக்க வேண்டும்.


The event may be likened to the occurrence of a symbol.

நிகழ்வு ஒரு சின்னத்தின் நிகழ்வுக்கு ஒப்பிடப்படலாம்.


The `rem` operator returns the remainder of a division.

`rem` ஆபரேட்டர் வகுத்தலின் மீதமுள்ளதை வழங்குகிறது.


The `mod` operator returns the modulo of a division, ensuring a result between 0 and y-1 for positive y.

`mod` ஆபரேட்டர் வகுத்தலின் மாடுலோவை வழங்குகிறது, நேர்மறை y க்கு 0 மற்றும் y-1 இடையே ஒரு முடிவை உறுதி செய்கிறது.


The functions `even` and `odd` return boolean values based on integer arguments.

`even` மற்றும் `odd` செயல்பாடுகள் முழு எண் வாதங்களின் அடிப்படையில் பூலியன் மதிப்புகளை வழங்குகின்றன.


Functions `max` and `min` take two arguments and return the maximum and minimum values, respectively.

`max` மற்றும் `min` செயல்பாடுகள் இரண்டு வாதங்களை எடுத்துக்கொள்கின்றன, மேலும் அதிகபட்ச மற்றும் குறைந்தபட்ச மதிப்புகளை முறையே வழங்குகின்றன.


Parentheses are only needed to enforce an evaluation order.

மதிப்பீட்டு வரிசையை செயல்படுத்த அடைப்புக்குறிகள் மட்டுமே தேவை.


The arithmetic relations are <, <=, ==, /=, >, >=, each returning a boolean result.

கணித உறவுகள் <, <=, ==, /=, >, >= ஆகும், ஒவ்வொன்றும் ஒரு பூலியன் முடிவை வழங்குகின்றன.


The equality operator is written as == and inequality as /=.

சமத்துவ ஆபரேட்டர் == என்றும், சமத்துவமின்மை /= என்றும் எழுதப்படுகிறது.


Haskell does not specify how to add an integer to a boolean.

ஒரு முழு எண்ணை ஒரு பூலியனுடன் எவ்வாறு சேர்ப்பது என்பதை Haskell குறிப்பிடவில்லை.


There are two boolean constants: True and False.

இரண்டு பூலியன் மாறிலிகள் உள்ளன: True மற்றும் False.


The boolean operators include not, &&, ||, ==, and /=.

பூலியன் ஆபரேட்டர்களில் not, &&, ||, ==, மற்றும் /= ஆகியவை அடங்கும்.


A character is enclosed within single quotes, and a string is enclosed within double quotes.

ஒரு எழுத்து ஒற்றை மேற்கோள்களுக்குள் வைக்கப்படுகிறது, மேலும் ஒரு சரம் இரட்டை மேற்கோள்களுக்குள் வைக்கப்படுகிறது.


You can compare characters using arithmetic relations.

கணித உறவுகளைப் பயன்படுத்தி எழுத்துக்களை ஒப்பிடலாம்.


The letters are ordered in the usual fashion, with uppercase letters smaller than lowercase.

எழுத்துக்கள் வழக்கமான முறையில் வரிசைப்படுத்தப்பட்டுள்ளன, பெரிய எழுத்துக்கள் சிறிய எழுத்துக்களை விட சிறியவை.


There are two functions defined on characters: ord and chr.

எழுத்துக்களில் வரையறுக்கப்பட்ட இரண்டு செயல்பாடுகள் உள்ளன: ord மற்றும் chr.


Function ord(c) returns the value of character c in the internal coding table.

ord(c) செயல்பாடு உள் குறியீட்டு அட்டவணையில் எழுத்து c இன் மதிப்பை வழங்குகிறது.


Function chr converts a number between 0 and 255 to the corresponding character.

chr செயல்பாடு 0 மற்றும் 255 க்கு இடைப்பட்ட எண்ணை தொடர்புடைய எழுத்துக்கு மாற்றுகிறது.


A string is a list of characters; all the rules about lists apply to strings.

ஒரு சரம் என்பது எழுத்துக்களின் பட்டியல்; பட்டியல்கள் பற்றிய அனைத்து விதிகளும் சரங்களுக்குப் பொருந்தும்.


We need to define functions to compute more complex operations.

மேலும் சிக்கலான செயல்பாடுகளை கணக்கிட நாம் செயல்பாடுகளை வரையறுக்க வேண்டும்.


An infix operator is written between its two arguments, whereas a prefix operator precedes its arguments.

ஒரு இடைநிலை ஆபரேட்டர் அதன் இரண்டு வாதங்களுக்கு இடையில் எழுதப்படுகிறது, அதே நேரத்தில் ஒரு முன்னொட்டு ஆபரேட்டர் அதன் வாதங்களுக்கு முன்னால் வருகிறது.


Functions bind more tightly than infix operators.

செயல்பாடுகள் இடைநிலை ஆபரேட்டர்களை விட இறுக்கமாக பிணைக்கப்படுகின்றன.


The program evaluates polynomials efficiently using Horner's rule.

ஹார்னர் விதியைப் பயன்படுத்தி நிரல் திறமையாக பல்லுறுப்புக்கோவைகளை மதிப்பிடுகிறது.


We are interested in proving properties of recursive programs to guarantee correctness.

சரியான தன்மையை உறுதிப்படுத்த, மறுநிகழ்வு நிரல்களின் பண்புகளை நிரூபிக்க நாங்கள் ஆர்வமாக உள்ளோம்.


The function 'rvc' combines list reversal and concatenation.

'rvc' என்ற செயல்பாடு பட்டியல் தலைகீழ் மற்றும் இணைப்பை ஒருங்கிணைக்கிறது.


Induction is our main tool in proving properties of functional programs.

செயல்பாட்டு நிரல்களின் பண்புகளை நிரூபிப்பதில் தூண்டல் எங்கள் முக்கிய கருவியாகும்.


The code for 'rvc' is defined to handle list operations.

'rvc'க்கான குறியீடு பட்டியல் செயல்பாடுகளைக் கையாள வடிவமைக்கப்பட்டுள்ளது.


We will use the associativity of ++ without explicitly referring to it.

நாம் அதை வெளிப்படையாகக் குறிப்பிடாமல் ++ இன் கூட்டல் பண்பைப் பயன்படுத்துவோம்.


The proof is by induction on the combined lengths of us and vs.

இந்த ஆதாரம் us மற்றும் vs ஆகியவற்றின் ஒருங்கிணைந்த நீளங்களில் தூண்டல் மூலம் உள்ளது.


The function 'foldr' is a higher-order function.

'foldr' என்ற செயல்பாடு ஒரு உயர் வரிசை செயல்பாடு ஆகும்.


Higher order functions are common and convenient in functional programming.

செயல்பாட்டு நிரலாக்கத்தில் உயர் வரிசை செயல்பாடுகள் பொதுவானவை மற்றும் வசதியானவை.


The type of foldr is (a -> a -> a) -> a -> [a] -> a.

foldr இன் வகை (a -> a -> a) -> a -> [a] -> a ஆகும்.


நாம் suml xs = foldr (+) 0 xs என வரையறுக்கலாம்.


Function 'map' takes a function and a list as arguments.

'map' என்ற செயல்பாடு ஒரு செயல்பாடு மற்றும் ஒரு பட்டியலை வாதங்களாக எடுத்துக்கொள்கிறது.


The type of map is (a -> b) -> [a] -> [b].

map இன் வகை (a -> b) -> [a] -> [b] ஆகும்.


Function 'filter' returns the list containing elements for which a predicate holds.

'filter' என்ற செயல்பாடு ஒரு முன்னொட்டுக்கு பொருந்தும் கூறுகளைக் கொண்ட பட்டியலை வழங்குகிறது.


The satisfiability problem is an important problem in computer science.

நிறைவுத்தன்மை பிரச்சனை கணினி அறிவியலில் ஒரு முக்கியமான பிரச்சனையாகும்.


A propositional formula is in Conjunctive Normal Form (CNF).

ஒரு முன்மொழிவு சூத்திரம் கூட்டு இயல்பான வடிவத்தில் (CNF) உள்ளது.


The Davis-Putnam procedure is an effective solution method.

டேவிஸ்-புட்னம் நடைமுறை ஒரு பயனுள்ள தீர்வு முறையாகும்.


We can represent a formula as a list of terms.

ஒரு சூத்திரத்தை சொற்களின் பட்டியலாக நாம் குறிப்பிடலாம்.


The top-level function 'dp' accepts a formula and returns a boolean.

'dp' என்ற உயர்நிலை செயல்பாடு ஒரு சூத்திரத்தை ஏற்றுக்கொண்டு ஒரு பூலியனை வழங்குகிறது.


The function 'reduce' scans through the terms of xss.

'reduce' என்ற செயல்பாடு xss இன் சொற்களை ஸ்கேன் செய்கிறது.


The execution time is at most logarithmic in the argument values.

செயல்பாட்டு நேரம், வாத மதிப்புகளில் அதிகபட்சமாக மடக்கையாக இருக்கும்.


We have, so far, seen a few elementary data types.

இதுவரை, சில ஆரம்ப தரவு வகைகளை நாம் பார்த்திருக்கிறோம்.


There are two important ways we can build larger structures using data from the elementary types— tuple and list.

ஆரம்ப வகைகளிலிருந்து தரவைப் பயன்படுத்தி பெரிய கட்டமைப்புகளை உருவாக்க இரண்டு முக்கியமான வழிகள் உள்ளன - டியூபிள் மற்றும் பட்டியல்.


Tuple is the Haskell’s version of a record; we may put several kinds of data together and give it a name.

டியூபிள் என்பது ஹாஸ்கெல்லின் பதிப்பாகும்; நாம் பல வகையான தரவுகளை ஒன்றாக வைத்து அதற்கு ஒரு பெயரை வைக்கலாம்.


In the simplest case, we put together two pieces of data and form a 2-tuple, also called a pair.

மிகவும் எளிமையான விஷயத்தில், நாம் இரண்டு தரவுகளை ஒன்றாக வைத்து, ஒரு 2-டியூபிளை உருவாக்குகிறோம், இது ஒரு ஜோடி என்றும் அழைக்கப்படுகிறது.


இதோ சில உதாரணங்கள்.


As you can see, the components may be of different types.

நீங்கள் பார்க்க முடியும் என, கூறுகள் வெவ்வேறு வகைகளைச் சேர்ந்தவையாக இருக்கலாம்.


Note that Haskell treats (3) and 3 alike, both are treated as numbers.

ஹாஸ்கெல் (3) மற்றும் 3 ஆகியவற்றை ஒரே மாதிரியாகக் கருதுகிறது, இரண்டும் எண்களாகக் கருதப்படுகின்றன என்பதை நினைவில் கொள்க.


There are two predefined functions, fst and snd, that return the first and the second components of a pair, respectively.

இரண்டு முன்னரே வரையறுக்கப்பட்ட செயல்பாடுகள் உள்ளன, fst மற்றும் snd, அவை ஒரு ஜோடியின் முதல் மற்றும் இரண்டாவது கூறுகளை முறையே வழங்குகின்றன.


There is no restriction at all in Haskell about what you can have as the first and the second component of a tuple.

ஹாஸ்கெல்லில் டியூபிளின் முதல் மற்றும் இரண்டாவது கூறாக நீங்கள் எதை வேண்டுமானாலும் வைத்திருக்கலாம் என்பதில் எந்த தடையும் இல்லை.


In particular, we can create another tuple hard = (teacher,course) and extract its first and second components by

குறிப்பாக, நாம் மற்றொரு டியூபிளை உருவாக்கலாம் hard = (teacher,course) மற்றும் அதன் முதல் மற்றும் இரண்டாவது கூறுகளை பிரித்தெடுக்கலாம்.


Haskell allows you to create tuples with any number of components, but fst and snd are applicable only to a pair.

ஹாஸ்கெல் எந்தவொரு கூறுகளையும் கொண்ட டியூபிள்களை உருவாக்க உங்களை அனுமதிக்கிறது, ஆனால் fst மற்றும் snd ஆகியவை ஒரு ஜோடிக்கு மட்டுமே பொருந்தும்.


Revisiting the Fibonacci Computation As we saw in the Figure 5.1 of page 133, there is considerable recomputation in evaluating fib n, in general.

பின்னோக்கிப் பார்ப்பது ஃபைபோனச்சி கணக்கீடு. பக்கம் 133 இன் படம் 5.1 இல் நாம் பார்த்தபடி, பொதுவாக fib n ஐ மதிப்பிடுவதில் கணிசமான மறு கணக்கீடு உள்ளது.


Here, I sketch a strategy to eliminate the recomputation.

இங்கே, மறு கணக்கீட்டை நீக்குவதற்கான ஒரு உத்தியை நான் வரைகிறேன்.


We define a function, called fibpair, which has an argument n, and returns the pair ((fib n), (fib (n+1))), i.e., two consecutive elements of the Fibonacci sequence.

fibpair எனப்படும் ஒரு செயல்பாட்டை நாம் வரையறுக்கிறோம், இது ஒரு வாதம் n ஐக் கொண்டுள்ளது, மேலும் ((fib n), (fib (n+1))) ஜோடியை வழங்குகிறது, அதாவது, ஃபைபோனச்சி வரிசையின் இரண்டு அடுத்தடுத்த கூறுகள்.


This function can be computed efficiently, as shown below, and we may define fib n = fst(fibpair n).

இந்தச் செயல்பாட்டை திறமையாகக் கணக்கிட முடியும், கீழே காட்டப்பட்டுள்ளது, மேலும் நாம் fib n = fst(fibpair n) என வரையறுக்கலாம்.


ஹாஸ்கெல்லில் உள்ள ஒவ்வொரு வெளிப்பாடும் ஒரு வகையைக் கொண்டுள்ளது.


The type may be specified by the programmer, or deduced by the interpreter.

வகையை நிரலாக்கர் குறிப்பிடலாம் அல்லது மொழிபெயர்ப்பாளர் மூலம் கழிக்கலாம்.


If you write 3+4, the interpreter can deduce the type of the operands and the computed value to be integer (not quite, as you will see).

நீங்கள் 3+4 என எழுதினால், மொழிபெயர்ப்பாளர் செயற்குறிகளின் வகையையும் கணக்கிடப்பட்ட மதிப்பையும் முழு எண்ணாகக் கழிக்க முடியும் (முழுமையாக இல்லை, நீங்கள் பார்ப்பீர்கள்).


Each function has a type, namely, the types of its arguments in order followed by the type of the result, all separated by ->.

ஒவ்வொரு செயல்பாடும் ஒரு வகையைக் கொண்டுள்ளது, அதாவது, அதன் வாதங்களின் வகைகள் வரிசையில், அதைத் தொடர்ந்து முடிவின் வகை, அனைத்தும் -> ஆல் பிரிக்கப்படுகின்றன.


Show that the execution time of reverse xs ys is O(n) where the length of xs is n.

xs இன் நீளம் n ஆக இருக்கும்போது, reverse xs ys இன் செயல்படுத்தும் நேரம் O(n) என்று காட்டு.


Prove from the definition of rev that rev (rev xs) = xs.

rev இன் வரையறையிலிருந்து rev (rev xs) = xs என்பதை நிரூபிக்கவும்.


Prove from the definition of rev and reverse that reverse xs ys = (rev xs) ++ ys.

rev மற்றும் reverse ஆகியவற்றின் வரையறையிலிருந்து reverse xs ys = (rev xs) ++ ys என்பதை நிரூபிக்கவும்.


Show how to right-rotate a list efficiently (i.e., in linear time in the size of the argument list).

ஒரு பட்டியலை எவ்வாறு திறமையாக வலதுபுறமாக சுழற்றுவது என்பதைக் காட்டுங்கள் (அதாவது, வாதப் பட்டியலின் அளவைப் பொறுத்து நேரியல் நேரத்தில்).


Right-rotation of [1,2,3,4] yields [4,1,2,3].

[1,2,3,4] இன் வலது சுழற்சி [4,1,2,3] ஐ விளைவிக்கிறது.


குறிப்பு: rev ஐப் பயன்படுத்தவும்.


இது ஒரு நன்கு அறியப்பட்ட புதிர்.


Given is a board on which there are three pegs marked ‘a’, ‘b’ and ‘c’, on each of which can rest a stack of disks.

ஒரு பலகை கொடுக்கப்பட்டுள்ளது, அதில் ‘a’, ‘b’ மற்றும் ‘c’ என மூன்று முளைகள் உள்ளன, ஒவ்வொன்றிலும் வட்டுக்களின் அடுக்குகள் ஓய்வெடுக்க முடியும்.


There are n disks, n > 0, of varying sizes, numbered 1 through n in order of size.

n வட்டுக்கள் உள்ளன, n > 0, வெவ்வேறு அளவுகளில், அளவின் வரிசையில் 1 முதல் n வரை எண்ணிடப்பட்டுள்ளன.


The disks are correctly stacked if they are increasing in size from top to bottom in each peg.

ஒவ்வொரு முளையிலும் மேலிருந்து கீழாக அவற்றின் அளவு அதிகரித்தால் வட்டுகள் சரியாக அடுக்கி வைக்கப்படுகின்றன.


Initially, all disks are correctly stacked at ‘a’.

ஆரம்பத்தில், அனைத்து வட்டுகளும் ‘a’ இல் சரியாக அடுக்கி வைக்கப்பட்டுள்ளன.


It is required to move all the disks to ‘b’ in a sequence of steps under the constraints that (1) in each step, the top disk of one peg is moved to the top of another peg, and (2) the disks are correctly stacked at all times.

அனைத்து வட்டுகளையும் ‘b’ க்கு ஒரு தொடர்ச்சியான படிகளில் நகர்த்த வேண்டும், இதில் (1) ஒவ்வொரு படியிலும், ஒரு முளையின் மேல் வட்டு மற்றொரு முளையின் மேல் நகர்த்தப்படுகிறது, மேலும் (2) வட்டுகள் எல்லா நேரங்களிலும் சரியாக அடுக்கி வைக்கப்பட வேண்டும்.


For n= 3, the sequence of steps given below is sufficient.

n= 3 க்கு, கீழே கொடுக்கப்பட்டுள்ள படிகளின் வரிசை போதுமானது.


In this sequence, a triple (i,x,y) denotes a step in which disk i is moved from peg x to y.

இந்த வரிசையில், ஒரு மும்மை (i,x,y) என்பது வட்டு i முளை x இலிருந்து y க்கு நகர்த்தப்படும் ஒரு படியைக் குறிக்கிறது.


Clearly, i is at the top of peg x before the step and at the top of peg y after the step.

படியின் முன் முளை x இன் மேற்புறத்திலும், படியின் பின் முளை y இன் மேற்புறத்திலும் i உள்ளது என்பது தெளிவாகிறது.


There is an iterative solution for this problem, which goes like this.

இந்த பிரச்சனைக்கு ஒரு மறுபடியும் தீர்வு உள்ளது, அது இப்படி செல்கிறது.


Disk 1 moves in every alternate step starting with the first step.

வட்டு 1 முதல் படியிலிருந்து தொடங்கி ஒவ்வொரு மாற்று படியிலும் நகர்கிறது.


If n is odd, disk 1 moves cyclically from ‘a’ to ‘b’ to ‘c’ to ‘a’..., and if n is even, disk 1 moves cyclically from ‘a’ to ‘c’ to ‘b’ to ‘a’....

n ஒற்றையாக இருந்தால், வட்டு 1 ‘a’ இலிருந்து ‘b’ க்கு ‘c’ க்கு ‘a’ க்கு சுழற்சி முறையில் நகரும்..., மற்றும் n இரட்டையாக இருந்தால், வட்டு 1 ‘a’ இலிருந்து ‘c’ க்கு ‘b’ க்கு ‘a’ க்கு சுழற்சி முறையில் நகரும்....


In each remaining step, there is exactly one possible move: ignore the peg of which disk 1 is the top; compare the tops of the two remaining pegs and move the smaller one to the top of the other peg (if one peg is empty, move the top of the other peg to its top).

மீதமுள்ள ஒவ்வொரு படியிலும், ஒரே ஒரு நகர்வு மட்டுமே சாத்தியமாகும்: வட்டு 1 மேல் இருக்கும் முளையை புறக்கணிக்கவும்; மீதமுள்ள இரண்டு முனைகளின் மேற்பகுதிகளை ஒப்பிட்டு, சிறியதை மற்ற முளையின் மேற்பகுதிக்கு நகர்த்தவும் (ஒரு முளை காலியாக இருந்தால், மற்ற முளையின் மேற்பகுதியை அதன் மேற்பகுதிக்கு நகர்த்தவும்).


I don’t know an easy proof of this iterative scheme; in fact, the best proof I know shows that this scheme is equivalent to an obviously correct recursive scheme.

இந்த மறுபடியும் திட்டத்தின் எளிதான ஆதாரம் எனக்குத் தெரியாது; உண்மையில், எனக்குத் தெரிந்த சிறந்த ஆதாரம், இந்தத் திட்டம் வெளிப்படையாக சரியான மறுநிகழ்வு திட்டத்திற்கு சமமானது என்பதைக் காட்டுகிறது.


In 150 seconds, of which about a minute is spent on initialization.

150 வினாடிகளில், சுமார் ஒரு நிமிடம் துவக்கத்திற்கு செலவிடப்படுகிறது.


The scheme they have developed is fairly robust with respect to machine failures.

அவர்கள் உருவாக்கிய திட்டம் இயந்திர தோல்விகளைப் பொறுத்தவரை மிகவும் வலுவானது.


The main idea behind their scheme is the observation that many web-based applications can be written as a map operation followed by a reduce operation.

அவர்களது திட்டத்தின் பின்னால் உள்ள முக்கிய யோசனை என்னவென்றால், பல இணைய அடிப்படையிலான பயன்பாடுகளை மேப் செயல்பாடாக எழுதலாம், அதைத் தொடர்ந்து குறைப்பு செயல்பாடு.


First, map is a function that takes a (key,value) pair as argument and returns a list of (key,value) pairs.

முதலில், மேப் என்பது ஒரு (விசை, மதிப்பு) ஜோடியை வாதமாக எடுத்து (விசை, மதிப்பு) ஜோடிகளின் பட்டியலை வழங்கும் ஒரு செயல்பாடு ஆகும்.


The argument keys and values may have different types from the result keys and values.

வாத விசைகளும் மதிப்புகளும் முடிவு விசைகள் மற்றும் மதிப்புகளிலிருந்து வேறுபட்ட வகைகளைக் கொண்டிருக்கலாம்.


As an example, the argument may be a pair (n,s), where n is a positive integer and s is a string.

ஒரு எடுத்துக்காட்டாக, வாதம் (n,s) ஜோடியாக இருக்கலாம், இங்கு n ஒரு நேர்மறை முழு எண்ணாகவும், s ஒரு சரமாகவும் இருக்கும்.


Here is the contents of a text document and n is a small value, say 12, which specifies the length of words of interest.

இதோ ஒரு உரை ஆவணத்தின் உள்ளடக்கம் மற்றும் n என்பது ஒரு சிறிய மதிப்பு, அதாவது 12, இது ஆர்வமுள்ள வார்த்தைகளின் நீளத்தை குறிப்பிடுகிறது.


Function map may return a list of (w,c) pairs.

மேப் செயல்பாடு (w,c) ஜோடிகளின் பட்டியலை வழங்கலாம்.


Typically, map is applied not to a single document, but millions of documents at once.

பொதுவாக, மேப் ஒரு ஆவணத்திற்கு அல்ல, ஆனால் ஒரே நேரத்தில் மில்லியன் கணக்கான ஆவணங்களுக்குப் பயன்படுத்தப்படுகிறது.


This feature allows us to deploy the massive cluster of computers effectively.

இந்த அம்சம் கணினிகளின் பெரிய கூட்டத்தை திறம்பட பயன்படுத்த அனுமதிக்கிறது.


Next, the outputs of all the maps, say M lists of (w,c) pairs for M documents, are aggregated into R lists where each list holds all the counts for a single word.

அடுத்து, அனைத்து மேப்களின் வெளியீடுகள், அதாவது M ஆவணங்களுக்கான (w,c) ஜோடிகளின் M பட்டியல்கள், R பட்டியல்களாக தொகுக்கப்படுகின்றன, அங்கு ஒவ்வொரு பட்டியலும் ஒரு வார்த்தைக்குரிய அனைத்து எண்ணிக்கையையும் வைத்திருக்கிறது.


Now, reduce operation is applied to each of these R lists individually, producing R outputs.

இப்போது, குறைப்பு செயல்பாடு இந்த R பட்டியல்கள் ஒவ்வொன்றிற்கும் தனித்தனியாகப் பயன்படுத்தப்படுகிறது, R வெளியீடுகளை உருவாக்குகிறது.


In this example, a reduce operation might sum up the counts, which will tell us something about the most commonly occurring words in all the documents.

இந்த எடுத்துக்காட்டில், ஒரு குறைப்பு செயல்பாடு எண்ணிக்கையை கூட்டக்கூடும், இது அனைத்து ஆவணங்களிலும் பொதுவாக நிகழும் வார்த்தைகளைப் பற்றி நமக்கு ஏதாவது சொல்லும்.


In general, the user provides the code for both map and reduce, specifies the arguments over which they have to be applied, and suggests certain parameters for parallel processing.

பொதுவாக, பயனர் மேப் மற்றும் குறைப்பு ஆகிய இரண்டிற்கும் குறியீட்டை வழங்குகிறார், அவை எதன் மீது பயன்படுத்தப்பட வேண்டும் என்பதை குறிப்பிடுகிறார், மேலும் இணையான செயலாக்கத்திற்கான சில அளவுருக்களை பரிந்துரைக்கிறார்.


The run-time system takes care of the details of partitioning the input data, scheduling the program’s execution across a set of machines, handling machine failures, and managing the required inter-machine communication.

இயக்க நேர அமைப்பு உள்ளீட்டு தரவை பிரித்தல், இயந்திரங்களின் தொகுப்பில் நிரலின் செயல்பாட்டை திட்டமிடுதல், இயந்திர தோல்விகளைக் கையாளுதல் மற்றும் தேவையான இயந்திரங்களுக்கிடையேயான தொடர்புகளை நிர்வகித்தல் போன்ற விவரங்களை கவனித்துக்கொள்கிறது.


This allows programmers without any experience with parallel and distributed systems to easily utilize the resources of a large distributed system.

சமாந்தர மற்றும் விநியோகிக்கப்பட்ட அமைப்புகளில் எந்த அனுபவமும் இல்லாத புரோகிராமர்கள் ஒரு பெரிய விநியோகிக்கப்பட்ட அமைப்பின் வளங்களை எளிதாகப் பயன்படுத்த இது அனுமதிக்கிறது.


Here are some examples that can be expressed as Map-Reduce computations.

மேப்-குறைப்பு கணக்கீடுகளாக வெளிப்படுத்தக்கூடிய சில எடுத்துக்காட்டுகள் இங்கே.


Distributed Grep “grep” is a unix utility that searches for a pattern in a given string.

விநியோகிக்கப்பட்ட கிரேப் “grep” என்பது ஒரு யூனிக்ஸ் பயன்பாடாகும், இது கொடுக்கப்பட்ட சரத்தில் ஒரு வடிவத்தைத் தேடுகிறது.


In this example, a large number of documents have to be searched for a specific pattern.

இந்த எடுத்துக்காட்டில், ஒரு குறிப்பிட்ட வடிவத்திற்காக ஏராளமான ஆவணங்களைத் தேட வேண்டும்.


Function map is applied to a document and a pattern, and it emits a line wherever there is a match.

மேப் செயல்பாடு ஒரு ஆவணம் மற்றும் ஒரு வடிவத்திற்குப் பயன்படுத்தப்படுகிறது, மேலும் பொருத்தம் இருக்கும் இடத்தில் ஒரு வரியை வெளியிடுகிறது.


The algorithm efficiently transforms data into a usable format.

இந்த வழிமுறை தரவை திறம்பட பயன்படுத்தக்கூடிய வடிவமாக மாற்றுகிறது.


Selection operations extract tuples that satisfy a specific condition.

தேர்வு செயல்பாடுகள் ஒரு குறிப்பிட்ட நிபந்தனையை பூர்த்தி செய்யும் டியூப்பிள்களை பிரித்தெடுக்கின்றன.


The projection operation lists only the required attributes.

திட்ட செயல்பாடு தேவையான பண்புகளை மட்டுமே பட்டியலிடுகிறது.


We use brackets of different shapes for readability.

படிக்க எளிதாக இருக்க வெவ்வேறு வடிவங்களின் அடைப்புக்குறிகளைப் பயன்படுத்துகிறோம்.


The transformed query is more efficient in evaluation.

மாற்றப்பட்ட வினவல் மதிப்பீட்டில் மிகவும் திறமையானது.


Selections are applied as soon as possible in the transformed expression.

தேர்வுகள் மாற்றியமைக்கப்பட்ட வெளிப்பாட்டில் கூடிய விரைவில் பயன்படுத்தப்படுகின்றன.


Aggregation operations combine values in a column.

திரட்டல் செயல்பாடுகள் ஒரு நெடுவரிசையில் உள்ள மதிப்புகளை ஒருங்கிணைக்கின்றன.


Grouping creates subrelations based on attribute values.

குரூப்பிங் பண்பு மதிப்புகளின் அடிப்படையில் துணை உறவுகளை உருவாக்குகிறது.


The SQL query language is widely used in the database community.

SQL வினவல் மொழி தரவுத்தள சமூகத்தில் பரவலாகப் பயன்படுத்தப்படுகிறது.


String matching algorithms locate occurrences of a pattern within a text.

சரம் பொருத்துதல் வழிமுறைகள் ஒரு உரையில் ஒரு வடிவத்தின் நிகழ்வுகளைக் கண்டறிகின்றன.


The naive algorithm matches the pattern at every possible position.

முட்டாள்தனமான வழிமுறை ஒவ்வொரு சாத்தியமான நிலையிலும் வடிவத்தை பொருத்துகிறது.


The Rabin-Karp algorithm uses hashing for string matching.

ராபின்-கார்ப் வழிமுறை சரம் பொருத்துவதற்கு ஹாஷிங்கைப் பயன்படுத்துகிறது.


Collisions can occur when different strings have the same hash value.

வெவ்வேறு சரங்கள் ஒரே ஹாஷ் மதிப்பைக் கொண்டிருக்கும்போது மோதல்கள் ஏற்படலாம்.


The Knuth-Morris-Pratt algorithm runs in linear time.

க்னுத்-மோரிஸ்-ப்ராட் வழிமுறை நேரியல் நேரத்தில் இயங்குகிறது.


The KMP algorithm is a refined version of the naive algorithm.

KMP வழிமுறை முட்டாள்தனமான வழிமுறையின் சுத்திகரிக்கப்பட்ட பதிப்பாகும்.


The core of a string is its longest proper prefix and suffix.

ஒரு சரத்தின் மையம் என்பது அதன் மிக நீண்ட சரியான முன்னொட்டு மற்றும் பின்னொட்டு ஆகும்.


The algorithm pre-computes the cores of all prefixes.

வழிமுறை அனைத்து முன்னொட்டுகளின் மையங்களையும் முன்கூட்டியே கணக்கிடுகிறது.


We need to find the longest string that is both a prefix and a suffix.

நாம் ஒரு முன்னொட்டு மற்றும் பின்னொட்டு ஆகிய இரண்டாக இருக்கும் மிக நீண்ட சரத்தைக் கண்டுபிடிக்க வேண்டும்.


The KMP algorithm avoids rescanning already matched text.

KMP வழிமுறை ஏற்கனவே பொருத்தப்பட்ட உரையை மீண்டும் ஸ்கேன் செய்வதைத் தவிர்க்கிறது.


The algorithm's efficiency is a key advantage.

வழிமுறையின் திறன் ஒரு முக்கிய நன்மை.


The function 'rev' reverses a powerlist.

'rev' என்ற செயல்பாடு ஒரு பவர்லிஸ்ட்டை தலைகீழாக்குகிறது.


Powerlists are used in parallel computing algorithms.

சமாந்தர கணினி வழிமுறைகளில் பவர்லிஸ்ட்கள் பயன்படுத்தப்படுகின்றன.


The base case of a powerlist is a singleton list, not an empty list.

ஒரு பவர்லிஸ்ட்டின் அடிப்படை நிலை ஒரு தனிப்பட்ட பட்டியல், காலியான பட்டியல் அல்ல.


We can define a function to rotate a powerlist.

ஒரு பவர்லிஸ்ட்டை சுழற்றுவதற்கான ஒரு செயல்பாட்டை நாம் வரையறுக்கலாம்.


The Fast Fourier Transform (FFT) is an important algorithm.

ஃபாஸ்ட் ஃபோரியர் டிரான்ஸ்ஃபார்ம் (FFT) ஒரு முக்கியமான வழிமுறை ஆகும்.


The length of a powerlist is a power of 2.

ஒரு பவர்லிஸ்ட்டின் நீளம் 2 இன் அடுக்கு ஆகும்.


Inductive proofs are often used with powerlists.

தூண்டல் ஆதாரங்கள் பெரும்பாலும் பவர்லிஸ்ட்களுடன் பயன்படுத்தப்படுகின்றன.


The shape and type of the scalar elements define the structure of a powerlist completely.

ஸ்கேலர் கூறுகளின் வடிவம் மற்றும் வகை ஒரு பவர்லிஸ்ட்டின் கட்டமைப்பை முழுமையாக வரையறுக்கின்றன.


Batcher sorting schemes are discussed in this paper.

பேட்சர் வரிசைப்படுத்தும் திட்டங்கள் இந்த கட்டுரையில் விவாதிக்கப்படுகின்றன.


The function 'inv' is defined by the following function on indices.

'inv' என்ற செயல்பாடு குறியீடுகளில் பின்வரும் செயல்பாட்டின் மூலம் வரையறுக்கப்படுகிறது.


For a powerlist of 2^n elements we associate an n-bit index with each element.

2^n உறுப்புகளைக் கொண்ட ஒரு பவர்லிஸ்ட்டுக்கு, ஒவ்வொரு உறுப்புடனும் ஒரு n-பிட் குறியீட்டை நாங்கள் தொடர்புபடுத்துகிறோம்.


The Gray code sequence is used for various applications.

கிரே குறியீடு வரிசை பல்வேறு பயன்பாடுகளுக்குப் பயன்படுத்தப்படுகிறது.


The function 'red' is used for reduction in linear list theory.

'red' என்ற செயல்பாடு நேரியல் பட்டியல் கோட்பாட்டில் குறைப்புக்கு பயன்படுத்தப்படுகிறது.


A polynomial can be represented by a powerlist.

ஒரு பல்லுறுப்புக்கோவையை ஒரு பவர்லிஸ்ட் மூலம் குறிப்பிடலாம்.


The inverse Fourier Transform can be defined similarly to the FFT.

தலைகீழ் ஃபோரியர் டிரான்ஸ்ஃபார்ம் FFT க்கு இதேபோல் வரையறுக்கப்படலாம்.


The compactness of this description of FFT is in striking contrast to the usual descriptions.

FFT இன் இந்த விளக்கத்தின் சுருக்கம் வழக்கமான விளக்கங்களுடன் வியக்கத்தக்க வகையில் வேறுபடுகிறது.


அடுத்து, FFT வழிமுறையை நாம் பெறுகிறோம்.


The function 'grr' rotates a powerlist to the right by k.

'grr' என்ற செயல்பாடு ஒரு பவர்லிஸ்ட்டை k ஆல் வலதுபுறமாக சுழற்றுகிறது.


The similarity restriction allows us to define complete binary trees.

சமமான கட்டுப்பாடு முழுமையான பைனரி மரங்களை வரையறுக்க அனுமதிக்கிறது.


The base case is a 1x1 matrix rather than an empty matrix.

அடிப்படை நிலை ஒரு 1x1 அணி, காலியான அணி அல்ல.


The algorithms in this paper use an inductive theorem prover.

இந்தக் கட்டுரையில் உள்ள வழிமுறைகள் ஒரு தூண்டல் தேற்ற நிரூபனியைப் பயன்படுத்துகின்றன.


They are extending their theorem prover.

அவர்கள் தங்கள் தேற்ற நிரூபனியை விரிவுபடுத்துகிறார்கள்.


One of the fundamental problems is devising compilation strategies.

அடிப்படைப் பிரச்சினைகளில் ஒன்று தொகுப்பு உத்திகளை உருவாக்குவதாகும்.


The architecture that is the closest conceptually is the hypercube.

கருத்து ரீதியாக மிக நெருக்கமான கட்டமைப்பு ஹைபர்கியூப் ஆகும்.


Combinational circuit verification is an area where powerlist notation may be employed.

கூட்டுச் சுற்றுகளைச் சரிபார்ப்பது பவர்லிஸ்ட் குறியீட்டைப் பயன்படுத்தக்கூடிய ஒரு பகுதியாகும்.


Adams has proved the correctness of adder circuits.

ஆடம்ஸ் கூட்டல் சுற்றுகளின் சரியான தன்மையை நிரூபித்துள்ளார்.


A ripple-carry adder is typically easy to describe.

ஒரு ரிப்பிள்-கேரி கூட்டல் பொதுவாக விவரிக்க எளிதானது.


A carry-lookahead adder is much more difficult.

கேரி-லுக்அஹெட் கூட்டல் மிகவும் கடினமானது.


He obtains a succinct description of the carry-lookahead circuit.

அவர் கேரி-லுக்அஹெட் சுற்றின் சுருக்கமான விளக்கத்தைப் பெறுகிறார்.


ஏதேனும் நீளத்தின் பவர்லிஸ்ட்கள்


The lengths of the powerlists have been restricted to be of the form 2^n.

பவர்லிஸ்ட்களின் நீளம் 2^n வடிவத்தில் இருக்க கட்டுப்படுத்தப்பட்டுள்ளது.


Steele suggests padding enough "dummy" elements.

ஸ்டீல் போதுமான "டമ്മി" கூறுகளைச் சேர்க்க பரிந்துரைக்கிறார்.


This scheme retains the simple algebraic laws of powerlist.

இந்தத் திட்டம் பவர்லிஸ்டின் எளிய இயற்கணித விதிகளைத் தக்க வைத்துக் கொள்கிறது.


Another approach is based on the observation.

மற்றொரு அணுகுமுறை இந்த அவதானிப்பை அடிப்படையாகக் கொண்டது.


The last line of this definition applies to a non-singleton list.

இந்த வரையறையின் கடைசி வரி ஒரு சிங்கிள் அல்லாத பட்டியலுக்குப் பொருந்தும்.


The notation proposed in this paper addresses only a small aspect.

இந்தக் கட்டுரையில் முன்மொழியப்பட்ட குறியீடு ஒரு சிறிய அம்சத்தை மட்டுமே குறிப்பிடுகிறது.


Powerlists have proved to be highly successful.

பவர்லிஸ்ட்கள் மிகவும் வெற்றிகரமாக நிரூபிக்கப்பட்டுள்ளன.


Parallel and sequential computations are interleaved.

இணை மற்றும் தொடர் கணக்கீடுகள் ஒன்றோடொன்று இணைக்கப்பட்டுள்ளன.


Gaussian elimination represents a mixture.

கௌசியன் நீக்கம் ஒரு கலவையை பிரதிபலிக்கிறது.


The powerlist notation can be integrated into a language.

பவர்லிஸ்ட் குறியீட்டை ஒரு மொழியில் ஒருங்கிணைக்க முடியும்.


The prefix sum is of fundamental importance in parallel computing.

முன்னொட்டுத் தொகை இணையான கணினியில் அடிப்படை முக்கியத்துவம் வாய்ந்தது.


We show that two known algorithms for this problem can be concisely represented and proved in our theory.

இந்த சிக்கலுக்கான இரண்டு அறியப்பட்ட வழிமுறைகளை எங்கள் கோட்பாட்டில் சுருக்கமாக பிரதிநிதித்துவப்படுத்தலாம் மற்றும் நிரூபிக்க முடியும் என்பதை நாங்கள் காட்டுகிறோம்.


Initially, processor i holds the list element L i, for all i.

ஆரம்பத்தில், செயலி i அனைத்து i க்கும் பட்டியல் உறுப்பு L i ஐ வைத்திருக்கிறது.


The connections among the processors at different levels depict data transmissions.

வெவ்வேறு மட்டங்களில் உள்ள செயலிகளுக்கு இடையேயான இணைப்புகள் தரவு பரிமாற்றங்களைக் காட்டுகின்றன.


Each processor updates its own data, d, to r ⊕ d where r is the data it receives.

ஒவ்வொரு செயலியும் அதன் சொந்த தரவை, d, r ⊕ d க்கு புதுப்பிக்கிறது, அங்கு r என்பது அது பெறும் தரவு ஆகும்.


Another scheme, due to Ladner and Fischer, first applies ⊕ to adjacent elements.

மற்றொரு திட்டம், லாட்னர் மற்றும் ஃபிஷர் காரணமாக, முதலில் ⊕ ஐ அருகிலுள்ள கூறுகளுக்குப் பயன்படுத்துகிறது.


This list has half as many elements as the original list.

இந்த பட்டியலில் அசல் பட்டியலில் உள்ளதை விட பாதி கூறுகள் உள்ளன.


Both schemes for prefix computation are inherently recursive.

முன்னொட்டு கணக்கீட்டிற்கான இரண்டு திட்டங்களும் உள்ளார்ந்த மறுநிகழ்வு கொண்டவை.


We introduce an operator in terms of which the prefix sum problem can be defined.

முன்னொட்டு தொகை சிக்கலை வரையறுக்கக்கூடிய ஒரு ஆபரேட்டரை நாங்கள் அறிமுகப்படுத்துகிறோம்.


For a powerlist p, let p* be the powerlist obtained by shifting p to the right by one.

ஒரு பவர்லிஸ்ட் p க்கு, p* என்பது p ஐ ஒன்றால் வலதுபுறமாக நகர்த்துவதன் மூலம் பெறப்பட்ட பவர்லிஸ்டாக இருக்கட்டும்.


This equation has a unique solution in z, because z0 = (z*)0 ⊕ L0 = 0 ⊕ L0 = L0, and zi+1 = zi ⊕ Li+1, 0 ≤ i < (len L) - 1

இந்த சமன்பாடு z இல் ஒரு தனித்துவமான தீர்வை கொண்டுள்ளது, ஏனெனில் z0 = (z*)0 ⊕ L0 = 0 ⊕ L0 = L0, மற்றும் zi+1 = zi ⊕ Li+1, 0 ≤ i < (len L) - 1


We define (ps L) to be the unique solution of (DE), and we call (DE) the defining equation for (ps L).

(ps L) ஐ (DE) இன் தனித்துவமான தீர்வாக நாங்கள் வரையறுக்கிறோம், மேலும் (DE) ஐ (ps L)க்கான வரையறுக்கும் சமன்பாடு என்று அழைக்கிறோம்.


The operator ⊕ is not necessarily commutative.

ஆபரேட்டர் ⊕ அவசியம் பரிமாற்றக்கூடியதாக இருக்க வேண்டியதில்லை.


The operator ⊕ is scalar; so, it commutes with ./.

ஆபரேட்டர் ⊕ ஸ்கேலர்; எனவே, இது ./ உடன் தொடர்பு கொள்கிறது.


The uniqueness of the solution of (DE) can be proved entirely within the powerlist algebra.

(DE) இன் தீர்வு தனித்துவமானது என்பதை பவர்லிஸ்ட் இயற்கணிதத்திற்குள் முழுமையாக நிரூபிக்க முடியும்.


The functions ps (simpleprefixsum) defines the scheme of Figure 8.4.

ps (எளிய முன்னொட்டுத்தொகை) படம் 8.4 இன் திட்டத்தை வரையறுக்கிறது.


In the first level in Figure 8.4, L* ⊕ L is computed.

படம் 8.4 இல் உள்ள முதல் மட்டத்தில், L* ⊕ L கணக்கிடப்படுகிறது.


Next, prefix sums of these two lists are computed (independently) and then zipped.

அடுத்து, இந்த இரண்டு பட்டியல்களின் முன்னொட்டு தொகைகள் கணக்கிடப்பட்டு (தனித்தனியாக) பின்னர் இணைக்கப்படுகின்றன.


The Ladner-Fischer scheme is defined by the function lf.

லாட்னர்-ஃபிஷர் திட்டம் lf என்ற செயல்பாடு மூலம் வரையறுக்கப்படுகிறது.


We can prove the correctness of sps and lf by showing that the function ps satisfies the equations defining each of these functions.

ps என்ற செயல்பாடு இந்த ஒவ்வொரு செயல்பாடுகளையும் வரையறுக்கும் சமன்பாடுகளை பூர்த்தி செய்கிறது என்பதைக் காட்டுவதன் மூலம் sps மற்றும் lf இன் சரியான தன்மையை நாம் நிரூபிக்க முடியும்.