Scribd
Upload
66 views6 pages

Merge

Merge combines two syntactic objects to form a new syntactic object. It is a recursive operation that can apply to its own outputs, building up larger syntactic structures from basic words. However, Merge on its own is too unconstrained and would allow nonsensical structures. Two important formal constraints are the Extension Condition, which requires Merge to join objects at their root nodes, and the Binary Branching Hypothesis, which requires Merge to join exactly two objects. These constraints help ensure Merge only combines objects in ways that produce valid constituent structures.

Uploaded by

CHRISTIAN GERALD
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
66 views6 pages

Merge

Merge combines two syntactic objects to form a new syntactic object. It is a recursive operation that can apply to its own outputs, building up larger syntactic structures from basic words. However, Merge on its own is too unconstrained and would allow nonsensical structures. Two important formal constraints are the Extension Condition, which requires Merge to join objects at their root nodes, and the Binary Branching Hypothesis, which requires Merge to join exactly two objects. These constraints help ensure Merge only combines objects in ways that produce valid constituent structures.

Uploaded by

CHRISTIAN GERALD
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 6

MERGE

Merge means combine or cause to combine to form a single entity.


Merge: takes a number of syntactic objects, and join them together to form a new syntactic
object

Some terminology:
Node: Object in a tree structure; Z, X and Y are nodes. Branch Line connecting nodes Mother:
The node at the top of a branch, with respect to a node below; Z is the mother of X and Y
Daughter: The node at the bottom of a branch with respect to the node above; X and Y are
daughters of Z
Sisters: Two nodes that have the same mother; two nodes that have been merged with each
other; X and Y are sisters.
Root: The unique node in a tree that has no mother Terminal: A node that has no daughters

Note that Merge is recursive, as required:


 It takes syntactic objects as its input and produces a new syntactic object as its output.
 That is, the output is the same type of thing as the input, and hence Merge can apply to its
own output.
 So we can string together multiple instances of Merge to create ever larger structures.
Merge as we’ve defined it is completely general, and on its own it is unconstrained. The null
hypothesis is that this is all there is to natural language syntax:
The simple Merge hypothesis: Sentences are formed by successive applications of Merge,
starting from the basic words of a language, and nothing else.
• Coupled with a complete lexicon, this will allow us to derive all of the sentences of a given
language.
• And what it derives will be hierarchical structures that can accurately reflect the constituent
structure of the sentences rather than flat strings.
Recall our example from last time:
 The surly pirate drank the rum.
Start with the following list of English words:
 {drank, pirate, rum, surly, the}
Now we can build up the (still rather simple) constituent structure that we arrived at for this
sentence by three successive applications of Merge.

Formal restrictions
Of course, the theory of syntax embodied by 8 is far too powerful:
• It will happily derive every imaginable hierarchical structure composed of the words in our list.
• In addition to all of the actual sentences we want, we get all sorts of nonsense like 11:
 And we get things that look like real sentences, with the right words in the right order,
but have the wrong structure:

So our job now is to figure out what restrictions to add to our simple hypothesis, constraining
Merge so that it only gives us structures corresponding to grammatical sentences.
 Part of the problem, as you may have noticed, is that we haven’t built sensitivity of
syntactic categories into our system yet.
 But before we get to that, let’s consider a couple of simple but powerful formal
constraints on the operation of Merge.
First, consider something that has been left implicit until now, but is absolutely crucial:
(13) The Extension Condition Merge always joins syntactic objects at their root nodes.
So the objects in 14a. and b. can only be merged as in 15a., not e.g., as in 15b.

Consider what this means:


• Merge takes whole constituents and combines them together on an equal footing.
• It can’t take one constituent and put it inside another.
• The only way to get constituent Y inside constituent X is if X is the new constituent
created by merging Y with something else.
Here’s why this is needed:
 Without the Extension Condition, we could revise constituents in the course of the
derivation.
 We could then no longer guarantee that the objects brought together by a single
instance of Merge would ultimately form a constituent.
 This would make it extremely difficult to develop any principled account of what
goes into constituency
 Note that the Extension Condition also keeps things simple and clear in an important
way:
 You can always figure out the steps of a derivation just by looking at the structure
that’s output at the end.
Here’s another formal restriction we should consider:
(16) The Binary Branching Hypothesis Merge always joins exactly two syntactic objects
together, never more nor less.
So these guys are out:

This is a working hypothesis.


• There is nothing that would inherently restrict Merge to being binary, and none of its
desirable properties that we’ve discussed would be lost if it weren’t binary.
• However, binary Merge is the minimum operation necessary to build larger structures.
• So Occam’s Razor dictates that we should try to get by with binary Merge alone, and only
add more complicated operations when necessary.
So here’s a more complete definition of Merge, updated to include the new constraints:
(18) Merge: Take two syntactic objects, and join them together at their roots to form a new
syntactic object

HOW TO MERGE ARRAY IN C PROGRAMMING.


Below here are some examples Merging programs
The program bellow assigns the user to declare the variables array of the first and second
array for constant merging.
#include<stdio.h>
int main(){
int A[4]={6,12,5,1};
int B[3]={56,2,7};
int merge[7];
int i,position;
merge[7]=A[4]+B[3];
for(i=0;i<4;i++){
merge[position]=A[i];
position++;
}
for(i=0;i<3;i++){
merge[position]=B[i];
position++;
}
for(i=0;i<7;i++){
printf("%4d",merge[i]);
}
return 0;
}

Write c program which will prompt a user to enter the size of the first array and its
elements, the size of the second array and its elements. The program should display the
merge of entered array.
#include<stdio.h>
int main(){
int A[100];
int B[100];
int merge[200];
int position, i;
int s1,s2,s3;
printf("Enter the size of 1st array\n");
scanf("%d",&s1);
printf("Enter elements\n");
for(i=0;i<s1;i++){
scanf("%d",&A[i]);
}
printf("Enter the size of 2nd array\n");
scanf("%d",&s2);
printf("Enter elements\n");
for(i=0;i<s2;i++){
scanf("%d",&B[i]);
}
s3=s1+s2;
for(i=0;i<s1;i++){
merge[position]=A[i];
position++;
}
for(i=0;i<s2;i++){
merge[position]=B[i];
position++;
}
printf("Merge is");
for(i=0;i<s3;i++){
printf("%4d",merge[i]);
}
return 0;
}

You might also like