chunk stringlengths 0 49.7k | embedding sequencelengths 1.02k 1.02k |
|---|---|
Every inertial body perceives itself to be at the center of the explosion of matter (see observable universe), and sees the local universe as homogeneous and isotropic in the sense of the cosmological principle. Unless the universe modeled has zero density, Milne's proposal does not follow the predictions of general relativity for the curvature of space caused by global matter distribution, as seen in, for example statistics associated with large-scale structure. Differences between Milne model and other models
In order to explain the existence of matter in the universe, Milne proposed a physical explosion of matter which would not affect the universe's geometry. This is in contrast to the metric expansion of space that is the hallmark feature of many of the more famous cosmological models including the Big Bang and Steady State models. Milne's universe shares a superficial similarity to Einstein's static universe in that the metric of space is not time-dependent. Unlike Einstein's initial cosmology, Milne's proposal directly contradicts the Einstein equations for cosmological scales. Special relativity becomes a global property of Milne's universe while general relativity is confined to a local property. The reverse is true for standard cosmological models, and most scientists and mathematicians agree that the latter is self-consistent while the former is mathematically impossible. Edward Arthur Milne predicted a kind of event horizon through the use of this model: "The particles near the boundary tend towards invisibility as seen by the central observer, and fade into a continuous background of finite intensity." | [
0.4011230469,
0.0643310547,
-0.7504882812,
-0.0778198242,
-0.6538085938,
0.2822265625,
0.0366516113,
0.2154541016,
-0.4533691406,
-0.357421875,
-0.1737060547,
0.0313110352,
-1.1572265625,
-0.3725585938,
0.6865234375,
-0.1708984375,
-0.3962402344,
0.1545410156,
-0.5092773438,
1.... |
The horizon arises naturally from length contraction seen in special relativity which is a consequence of the speed of light upper bound for physical objects. In Milne's universe, the velocities of objects approach this upper bound while the distance to these objects approaches the speed of light multiplied by the time since the event of the initial explosion of material. Beyond this distance, objects do not lie in the observable part of the Milne universe. At the time Milne proposed his model, observations of the universe did not appear to be in a homogeneous form. This, to Milne, was a deficiency inherent in the competing cosmological models which relied on the cosmological principle that demanded a homogeneous universe. “This conventional homogeneity is only definite when the motion of the particles is first prescribed.” With present observations of the homogeneity of the universe on the largest scales seen in the cosmic microwave background and in the so-called "End of Greatness", questions about the homogeneity of the universe have been settled in the minds of most observational cosmologists. Notes
References
Milne Cosmology: Why I Keep Talking About It - a detailed non-technical introduction to the Milne model
Wegener, Mogens True. Non-Standard Relativity: A Philosopher's Handbook of Heresies in Physics. BoD–Books on Demand, 2016. A thorough historical and theoretical study of the British Tradition in Cosmology, and one long celebration of Milne. Obsolete theories in physics
Exact solutions in general relativity
Minkowski spacetime
1935 in science | [
-0.125,
-0.5141601562,
-1.2265625,
-0.283203125,
-0.1320800781,
-0.0815429688,
0.2683105469,
-0.0503845215,
0.5751953125,
0.1274414062,
-1.0478515625,
-0.2061767578,
-0.919921875,
-0.2673339844,
1.341796875,
-0.2878417969,
-0.4528808594,
-0.3835449219,
-0.8232421875,
1.46484375... |
In computer science, a grid file or bucket grid is a point access method which splits a space into a non-periodic grid where one or more cells of the grid refer to a small set of points. Grid files (a symmetric data structure) provide an efficient method of storing these indexes on disk to perform complex data lookups. It provides a grid of n-dimensions where n represents how many keys can be used to reference a single point. Grid files do not contain any data themselves but instead contain references to the correct bucket. Uses
A grid file is usually used in cases where a single value can be referenced by multiple keys. A grid file began being used because "traditional file structures that provide multikey access to records, for example, inverted files, are extensions of file structures originally designed for single-key access. They manifest various deficiencies in particular for multikey access to highly dynamic files." In a traditional single dimensional data structure (e.g. hash), a search on a single criterion is usually very simple but searching for a second criterion can be much more complex. Grid files represent a special kind of hashing, where the traditional hash is replaced by a grid directory. Examples
Census DatabaseElmasri & Navathe Fundamentals of Database Systems, Third Edition. Addison-Wesley, 2000. . Section 6.4.3: Grid Files, pp.185. Consider a database containing data from a census. A single record represents a single household, and all records are grouped into buckets. | [
0.9619140625,
-0.892578125,
-0.76171875,
0.2268066406,
-0.0618896484,
0.2277832031,
0.7177734375,
0.0320129395,
-0.3154296875,
0.1257324219,
0.0863037109,
0.0198822021,
0.505859375,
-0.1616210938,
-0.7924804688,
0.6352539062,
0.0718994141,
0.042175293,
0.01537323,
-0.1837158203... |
All records in a bucket can be indexed by either their city (which is the same for all records in the bucket), and the streets in that city whose names begin with the same letter. A grid file can be used to provide an efficient index for this structure, where records come in groupings of 26, each of them relating to street names in a city starting with one of the letters of the alphabet. This structure can be thought of as an array, table, or grid with two dimensions which we will call the x and y axes. One may consider the x-axis to be the city and the y-axis to be each of the letters in the alphabet, or alternatively, the first letter of each street. Each record in this structure is known as a cell. Each cell will contain a pointer to the appropriate bucket in the database where the actual data is stored. An extra cell, or record header, may be required to store the name of the city. Other cells grouped with it will only need to contain the pointer to their respective bucket, since the first cell corresponds to street names beginning with "A", the second to "B", and so on. The database can be further extended to contain a continent field to expand the census to other continents. This would cause records in the same bucket to correspond to households on a street beginning with the same letter, in the same city, in the same continent. | [
0.9506835938,
-0.8735351562,
-0.9165039062,
0.0905761719,
0.2078857422,
0.7192382812,
0.6655273438,
0.4240722656,
-0.1185302734,
-0.0993041992,
-0.1606445312,
-0.267578125,
0.2329101562,
-0.26953125,
-0.4311523438,
0.6430664062,
-0.1782226562,
0.060760498,
-0.7739257812,
0.1959... |
The cells in the grid file would then consist of a city header, and six (one for each continent, not including Antarctica) groupings of 26 cells relating to the streets with the same starting letter, in the same city, on the same continent and could now be thought of as a three-dimensional array. Advantages
Since a single entry in the grid file contains pointers to all records indexed by the specified keys:
No special computations are required
Only the right records are retrieved
Can also be used for single search key queries
Easy to extend to queries on n search keys
Significant improvement in processing time for multiple-key queries
Has a two-disk-access upper bound for accessing data. Disadvantages
However, because of the nature of the grid file, which gives it its advantages, there are also some disadvantages:
Imposes space overhead
Performance overhead on insertion and deletion
Related Data Structures
multilayer grid file
twin grid files
BANG file
See also
Lattice graph
Grid (spatial index)
Index (database), Quadtree, Kd-tree, UB-tree, R-tree, range tree as alternatives. References
Computer files
Arrays | [
0.9423828125,
-0.77734375,
-0.58984375,
0.2135009766,
0.1748046875,
0.0614929199,
1.3291015625,
-0.1395263672,
-0.75390625,
0.0740356445,
-0.2658691406,
0.4267578125,
1.189453125,
-0.341796875,
-1.8291015625,
1.3134765625,
-0.0882568359,
-0.1928710938,
-0.0293579102,
0.00194263... |
SYN cookie is a technique used to resist SYN flood attacks. The technique's primary inventor Daniel J. Bernstein defines SYN cookies as "particular choices of initial TCP sequence numbers by TCP servers." In particular, the use of SYN cookies allows a server to avoid dropping connections when the SYN queue fills up. Instead of storing additional connections, a SYN queue entry is encoded into the sequence number sent in the SYN+ACK response. If the server then receives a subsequent ACK response from the client with the incremented sequence number, the server is able to reconstruct the SYN queue entry using information encoded in the TCP sequence number and proceed as usual with the connection. Implementation
In order to initiate a TCP connection, the client sends a TCP SYN packet to the server. In response, the server sends a TCP SYN+ACK packet back to the client. One of the values in this packet is a sequence number, which is used by the TCP to reassemble the data stream. According to the TCP specification, that first sequence number sent by an endpoint can be any value as decided by that endpoint. As the sequence number is chosen by the sender, returned by the recipient, and has no otherwise-defined internal structure, it can be overloaded to carry additional data. The following describes one possible implementation, however as there is no public standard to follow, the order, length, and semantics of the fields may differ between SYN cookie implementations. | [
-0.0817871094,
0.0650634766,
-0.3225097656,
0.2604980469,
-0.3093261719,
-0.4423828125,
-0.6728515625,
0.0639038086,
0.0623168945,
0.1934814453,
-0.4440917969,
0.1965332031,
0.958984375,
0.4821777344,
0.5234375,
0.701171875,
-0.1293945312,
0.0687255859,
-0.1171264648,
1.2216796... |
SYN cookies are initial sequence numbers that are carefully constructed according to the following rules:
let t be a slowly incrementing timestamp (typically logically right-shifted 6 positions, which gives a resolution of 64 seconds)
let m be the maximum segment size (MSS) value that the server would have stored in the SYN queue entry
let s be the result of a cryptographic hash function computed over the server IP address and port number, the client IP address and port number, and the value t. The returned value s must be a 24-bit value. The initial TCP sequence number, i.e. the SYN cookie, is computed as follows:
Top 5 bits: t mod 32
Middle 3 bits: an encoded value representing m
Bottom 24 bits: s
(Note: since m must be encoded using 3 bits, the server is restricted to sending up to 8 unique values for m when SYN cookies are in use.) When a client sends back a TCP ACK packet to the server in response to the server's SYN+ACK packet, the client must (according to the TCP spec) use n+1 in the packet's Acknowledgement number, where n is the initial sequence number sent by the server. The server then subtracts 1 from the acknowledgement number to reveal the SYN cookie sent to the client. The server then performs the following operations. Checks the value t against the current time to see if the connection has expired. Recomputes s to determine whether this is, indeed, a valid SYN cookie. | [
-0.3747558594,
-0.0469970703,
-0.2639160156,
0.3461914062,
-0.884765625,
-0.1645507812,
-0.9252929688,
0.2165527344,
0.1735839844,
0.0257263184,
-0.0660400391,
-0.0816650391,
0.8725585938,
0.6376953125,
0.2476806641,
0.541015625,
-0.1312255859,
0.0662841797,
-0.5849609375,
1.03... |
Decodes the value m from the 3-bit encoding in the SYN cookie, which it then can use to reconstruct the SYN queue entry. From this point forward, the connection proceeds as normal. Drawbacks
The use of SYN cookies does not break any protocol specifications, and therefore should be compatible with all TCP implementations. There are, however, two caveats that take effect when SYN cookies are in use. Firstly, the server is limited to only 8 unique MSS values, as that is all that can be encoded in 3 bits. Secondly, early implementations rejected all TCP options (such as large windows or timestamps), because the server discarded the SYN queue entry where that information would otherwise be stored. ; however v2.6.26 of the Linux kernel added partial support of TCP options by encoding them into the timestamp option. Finally, SYN cookies place increased load on server resources. Encrypting responses is computationally expensive. The SYN cookie does not reduce traffic, which makes it ineffective against SYN flooding attacks that target bandwidth as the attack vector. While these restrictions necessarily lead to a sub-optimal experience, their effect is rarely noticed by clients because they are only applied when under attack. In such a situation, the loss of the TCP options in order to save the connection is usually considered to be a reasonable compromise. A problem arises when the connection-finalizing ACK packet sent by the client is lost, and the application layer protocol requires the server to speak first (SMTP and SSH are two examples). | [
-0.2868652344,
-0.2858886719,
-0.3178710938,
-0.0924072266,
-0.51171875,
-0.4455566406,
0.1401367188,
-0.5415039062,
-0.4953613281,
0.2205810547,
-0.6748046875,
0.2961425781,
1.1884765625,
0.0524597168,
0.4118652344,
1.216796875,
-0.1329345703,
-0.0442504883,
-0.2185058594,
1.7... |
In this case, the client assumes that the connection was established successfully and waits for the server to send its protocol banner, or resend the SYN+ACK packet; however, the server is not aware of the session and will not resend the SYN+ACK because it discarded the backlog queue entry that would enable it to do so. Eventually, the client will abort the connection due to an application layer timeout, but this may take a relatively long time. TCP Cookie Transactions (TCPCT) standard was designed to overcome these shortcomings of SYN cookies and improve it on a couple of aspects. Unlike SYN cookies, TCPCT is a TCP extension and required support from both endpoints. It was moved to "Historic" status by RFC 7805 in 2016. Security considerations
Simple firewalls that are configured to allow all outgoing connections but to restrict which ports an incoming connection can reach (for example, allow incoming connections to a Web server on port 80 but restrict all other ports), work by blocking only incoming SYN requests to unwanted ports. If SYN cookies are in operation, care should be taken to ensure an attacker is not able to bypass such a firewall by forging ACKs instead, trying random sequence numbers until one is accepted. SYN cookies should be switched on and off on a per-port basis, so that SYN cookies being enabled on a public port does not cause them to be recognised on a non-public port. | [
-0.1793212891,
-0.5673828125,
-0.2590332031,
-0.1340332031,
-0.7055664062,
-0.537109375,
-0.9892578125,
-0.4682617188,
0.6376953125,
0.7197265625,
-0.3901367188,
-0.189453125,
0.4868164062,
0.6943359375,
0.4689941406,
0.4367675781,
-0.1132202148,
0.0921630859,
-0.4326171875,
1.... |
The original Linux kernel implementation misunderstood this part of Bernstein's description and used a single global variable to switch on SYN cookies for all ports; this was pointed out by a research student and subsequently fixed in . History
The technique was created by Daniel J. Bernstein and Eric Schenk in September 1996. The first implementation (for SunOS) was released by Jeff Weisberg a month later, and Eric Schenk released his Linux implementation in February 1997. FreeBSD implements syncookies since FreeBSD 4.5 (January 2002). See also
SYN flood
IP Spoofing
TCP Cookie Transactions
References
External links
D. J. Bernstein's own explanation of SYN cookies
Appendix A
Computer network security
Transmission Control Protocol | [
0.5693359375,
-0.2502441406,
0.0643920898,
-0.1369628906,
-0.3591308594,
-0.1583251953,
-0.8701171875,
0.1926269531,
-0.1887207031,
0.244140625,
0.4609375,
0.708984375,
0.0437316895,
0.6123046875,
-0.376953125,
0.146484375,
-0.1522216797,
0.1801757812,
-0.4147949219,
1.14453125... |
A self-extracting archive (SFX or SEA) is a computer executable program which contains compressed data in an archive file combined with machine-executable program instructions to extract this information on a compatible operating system and without the necessity for a suitable extractor to be already installed on the target computer. The executable part of the file is known as a decompressor stub. Self-extracting files are used to share compressed files with a party that may not necessarily have the software to decompress the file. Users can also use self-extracting to distribute their own software. For example, the WinRAR installation program is made using the graphical GUI RAR self-extracting module Default.sfx. Overview
It incorporates an executable file module, a module used to run uncompressed files from compressed files. Such a compressed file does not require an external program to decompress the contents of the self-extracting file, and it can run the operation itself. However, file archivers like WinRAR can still treat self-extracting files as any other compressed files. Users who are unwilling to run the self-extracting file they received (for example, when it may contain a virus) can use the file archiver to view or decompress its content without running executable code. On executing a self-extracting archive under an operating system which supports it, the archive contents are extracted and stored as files on the disk. Often, the embedded self-extractor supports a number of command line arguments to control the behaviour, i.e. to specify the target location or select only specific files to be extracted. Non-self-extracting archives contain the archived files only and therefore need to be extracted with a compatible program. | [
-0.1994628906,
-0.1201782227,
0.3291015625,
-0.1407470703,
-0.4389648438,
0.6127929688,
-1.048828125,
-0.5703125,
0.3618164062,
-0.2416992188,
0.2841796875,
0.3845214844,
0.1898193359,
0.658203125,
0.0174865723,
0.1658935547,
-0.3022460938,
0.7739257812,
-0.0519714355,
0.994140... |
Self-extracting archives cannot self-extract under a different operating system but most often can still be opened with a suitable extractor as this tool will disregard the executable part of the file and instead extract only the archive resource. In some cases this requires the self-extracting executable to be renamed to hold a file extension associated with the corresponding packer. Self-extracting files usually have an .exe extension like other executable files. For example, an archive may be called somefiles.zip - it can be opened under any operating system by a suitable archive manager which supports both the file format and compression algorithm used. It could alternatively be converted into somefiles.exe which will self-extract on a machine running Microsoft Windows without the need for that suitable archive manager. It will not self-extract under Linux, but can be opened with a suitable Linux archive manager. There are several functionally equivalent but incompatible archive file formats, including ZIP, RAR, 7z and many others. Some programs can manage (create, extract, or modify) only one type of archive whilst many others can handle multiple formats. There is additionally a distinction between the file format and compression algorithm used. A single file format, such as 7z, can support multiple different compression algorithms including LZMA, LZMA2, PPMd and BZip2. For a decompression utility to correctly expand an archive of either the self-extracting or standard variety, it must be able to operate on both the file format and algorithm used. The exact executable code placed at the beginning of a self-extracting archive may therefore need to be varied depending on what options were used to create the archive. | [
-0.0231933594,
-0.5844726562,
0.0245361328,
0.1391601562,
-0.916015625,
0.9013671875,
-0.7436523438,
-0.5083007812,
0.662109375,
-0.6694335938,
0.0441894531,
0.5625,
0.3063964844,
0.7119140625,
-0.2235107422,
0.94921875,
-0.5654296875,
0.7758789062,
0.1641845703,
1.412109375,
... |
The decompression routines will be different for a LZMA 7z archive when compared with a LZMA2 7z archive, for example. Several programs can create self-extracting archives. For Windows there is WinZip, WinRAR, 7-Zip, WinUHA, KGB Archiver, Make SFX, the built-in IExpress wizard and many others, some experimental. For Macintosh there are StuffIt, The Unarchiver, and 7zX. There are also programs that create self-extracting archives on Unix as shell scripts which utilizes programs like tar and gzip (which must be present in destination system). Others (like 7-Zip or RAR) can create self-extracting archives as regular executables in ELF format. An early example of a self-extracting archive was the Unix shar archive in which one or more text files were combined into a shell script that when executed recreated the original files. Self-extracting archives can be used to archive any number of data as well as executable files. They must be distinguished from executable compression, where the executable file contains a single executable only and running the file does not result in the uncompressed file being stored on disk, but in its code being executed in memory after decompression. Advantages
Archiving files rather than sending them separately allows several related files to be combined into a single resource. It also has the benefit of reducing the size of files not already efficiently compressed (many compression algorithms cannot make already compressed data any smaller. Compression will therefore usually reduce the size of a plain text document but hardly affect a JPEG picture or a word processor document. | [
0.3803710938,
-0.1954345703,
0.4621582031,
-0.314453125,
-0.5771484375,
0.66796875,
-0.1982421875,
-0.3696289062,
-0.0635986328,
-0.9487304688,
0.1221923828,
0.76171875,
0.5034179688,
0.26171875,
-0.2357177734,
0.869140625,
-0.6552734375,
0.8276367188,
0.1104736328,
1.66015625,... |
End of preview. Expand in Data Studio
README.md exists but content is empty.
- Downloads last month
- 5