OpenLLM-France/wikimedia huggingface dataset:
# Ricoeur Commentary

Welcome to the wiki-based commentary on the writings of Paul Ricoeur.

## Organization

This Wikibook approaches Ricoeur's writings in three different ways:
* Topics that arise repeatedly throughout his works;
* Books, analyzed on a page-by-page basis; and
* Discussions presenting critiques of or extended elaborations upon Ricoeur, going beyond individual pages or topics.

## Introductory Remarks

Note: do not post excerpts directly from Ricoeur's writings. They will continue to be protected by copyright for some years to come. Instead, just refer to specific pages and indicate the text on which you are offering commentary.
Please feel free to add your papers, notes, or anything else that will help to clarify the meaning of Ricoeur's writings!
# Ricoeur Commentary/Books
## Books

* The Rule of Metaphor: Multi-Disciplinary Studies in the Creation of Meaning in Language
    French origin. in 1975
    English trans. by Robert Czerny, et al. in 1978
* Interpretation Theory: Discourse and the Surplus of Meaning
    Texas Christian University Press, 1976
    "Language as Discourse"; see: Amazon reader
# Riemann Hypothesis

The Riemann hypothesis is considered to be one of the most important conjectures within pure mathematics, which has stood unsolved for over 150 years. This wikibook seeks to explore the hypothesis, its history, and its current status.

## Table of Contents

* Preliminary knowledge
* Biography of Riemann
* Introduction to the Zeta function
* Analytical continuation
* The hypothesis
* Computation using the Zeta function
* Notability of the problem
* Consequences
* Attempted proofs
* Potential future methods
* Arguments and counterarguments
* Generalised Riemann Hypothesis
* Related problems
* Appendix
# Riemann Hypothesis/Analytical continuation
## Definition 1

Suppose $f$ is an analytic function defined on some non-empty open subset of $\mathbb {C}$, $\mathbb {A}$. Suppose $\mathbb {B}$ is also an open subset of $\mathbb {C}$ with cardinality greater than that of $\mathbb {A}$, containing all elements of $\mathbb {A}$. If $g$ is also an analytic function, defined on $\mathbb {B}$, such that,
    $f(s)=g(s)\forall s\in \mathbb {A}$
then $g$ may be called an analytical continuation of $f$.
# Riemann Hypothesis/Biography of Riemann

Bernhard Riemann was born in the Kingdom of Hanover, in modern Germany, in 1826. From an early age, Riemann directed much of his interest towards theology and philology. While he excelled in mathematics, he was rather timid and shy, and neglected to display much of his ability. When Riemann attended the University of Göttingen, he initially aspired to study Theology. At university, Riemann met Gauss, who advised him to give up his theological studies, and pursue mathematics. He later transferred to the University of Berlin to read mathematics, where several notable mathematicians, including Steiner, Jacobi and Dirichlet (from whom he would borrow concepts for his later studies). Riemann died from tuberculosis on a trip to Italy in 1866. Despite his early death, Riemann left a significant legacy that can still be seen in mathematics to this day.
Riemann's academic work primarily concerned analysis, number theory and differential geometry. He is credited with his contribution of the Riemann integral, the first formal, rigorous, definition of an integral, Riemann surfaces and Riemannian geometry, the latter being later used by Einstein as part of his theory of General Relativity. This piece concerns Riemann's research in real analysis, specifically prime numbers, where he explored the distribution of prime numbers, later proposing the Riemann Hypothesis in 1859.
Riemann published his paper, "On the Number of Primes Less Than a Given Magnitude" (Ueber die Anzahl der Primzahlen unter einer gegebenen Grösse) in 1859, in the journal "Monatsberichte der Königlich Preußischen Akademie der Wissenschaften zu Berlin". The paper's primary focus is the prime-counting functions, $\pi$, which, as the title of the paper suggests, gives the number of primes less than a given argument. Among other things, Riemann introduced definitions, proofs and methods that would later prove to be invaluable in further research, including Fourier inversion, analytical continuation, and Contour integration.

### References

* O'Connor, J. J and Robertson, E. F (1998). "Biography of Bernhard Riemann". School of Mathematics and Statistics, University of St. Andrews. Retrieved August 13, 2017.{{cite web}}: CS1 maint: multiple names: authors list (link)
* Riemann, Bernhard (November 1859). Ueber die Anzahl der Primzahlen unter einer gegebenen Grösse.
# Rust for the Novice Programmer/Basic Maths Testing Program/Getting Started
## Getting Started with our Maths Program

Let's start a new program by going to a new folder in the terminal and typing 'cargo init'. Then we can open up main.rs in the src/ folder. Let's start off by writing a function to take in the numbers and print out the question to the terminal.
And in our main function, we call it like so:
And if we run this now with 'cargo run' we get
in the terminal.
However, this only works with addition. Let's make it work for both addition and subtraction. To represent the mathematical operator, we need something that can be one of a number of options. The perfect way to represent this is with an enum. So we create our enum as follows:
Now, to display the operator, we can match against the operator and select the character for it, so we change our print_question function as follows:
And we can change our main function to:
And now when we run cargo run, we get
in the terminal.
Next: we introduce traits as a cleaner way to display the operator.
# Rust for the Novice Programmer/Basic Maths Testing Program/Traits and Displaying
## Traits and Displaying

Very little in Rust is magic. A lot of the stuff we've learned and used earlier could be reimplemented in our code. What we would like to do in our program is to use "" to display the operator directly.
What we want to write in our print_question is this:
However, if we try to run this, we get the message:
The way things like println! works in Rust is that when it sees "", it checks whether the corresponding object after the comma implements a 'Trait' called 'Display'. A trait is like a marker on a type, indicating that it has certain methods that can be used.
If we look at the docs for std::fmt::Display we see that the trait has:
We do have to remember this is all under std::fmt so we have to put this before each type. A lot of this will look quite strange but essentially we have to write a function that matches this, we can use the macro write! to make things easier like follows:
The std::fmt::Result on its own is a shorthand for the Result<, Error> above. Also the std::fmt:: before everything is a little tiresome. What we can do is put
at the top and change our implementation of the Display trait as follows:
The use statement means whenever the code encounters fmt, it will assume it is std::fmt. This is helpful in reducing the amount of code we have to write but can also be dangerous if we have our instance of fmt since it won't be able to be distinguished. That is unlikely to be the case for us so we can be comfortable making this change. We don't have to put it at the top but generally we will want to put all of our use statements in the same place. That being written, if we run the program now we get:
Oops, we didn't check which operator it is, let's fix that now:
Now if we run the program, we get:
which is what we wanted.
All this may seem a little convoluted but there's a few advantages of doing things like this:
* Reuse, we can now easily print out the operator in a different place easily
* Breaking up the problem, we don't want everything in the same function, or the same place. In this way the Operator type and functionality is separated out from the other parts of the program.
* Easier to edit, since everything is in the same place we just have to change the logic in the Operator type and related functions and all uses of it in other places will be correct.
Next: we look at how to take in user input
# Russian History/Preface

* Lansereships
* Ancient Russian Girl by Nicholas Roerich, 1910
* Appearance of Catherine
* Ivan Vladimirov's painting The Barricades of Pesnya, 1905
* Gulag prisoners at work 1936-1937
* Battle of Stalingrad
   "Russia is a riddle wrapped in a mystery wrapped in an enigma." -Winston Churchill
# Rust for the Novice Programmer/Basic Maths Testing Program/String to Number
## Converting a String to a Number

So now we have read a String out of the standard input. But we want to convert it into a number. To do this, we use the following function inside i32:
The src is the string we are converting into a number. The radix is the base of the number we want to convert to. We only want to use base 10 since that's what people will type in. Also the function returns a Result indicating that this function can fail. We could use .unwrap on the result but this means the program would crash if the user ever typed in anything that couldn't be converted to a number. Instead we want to handle the error properly, and if the user input can't be converted to a number we should ask the user to enter again. Here's what that looks like:
Note that we loop while the result is an error, so the unwrap at the end will always be safe. Also we have to clear the buffer between each go. Now let's test this and see how it works!
Oh dear. Note that we use Ctrl-C to escape the program when it's in a loop like this. But what's the problem? Why can't it parse the string as a number properly? Well let's add a debug println! statement to see what the value of buffer is right before it gets parsed:
Then when we run it, it prints out:
What are those characters at the end of the string? Well essentially since we have to press Enter to submit the number, this adds a newline to standard input which is included in the buffer. Another annoying thing is that what the newline is depends on your operating system, generally Windows use "\r\n" while other operating systems use "\n". We want to handle both cases, so we will add a line to replace all of these characters with empty strings, so our function becomes:
Now our function works, when we run it we get these results:
And the program exits as we expect!
Next: checking whether the user inputted number matches the expected number
# Rust for the Novice Programmer/Basic Maths Testing Program/Randomness and External crates
## Randomness and External Crates

It makes no sense to just ask the same question over and over again, so what we want to do is randomise the numbers and the operator that the user has to calculate the result of. However, we have an issue since generating random numbers isn't in the standard library. This means we have to use an external library to get what we want, this has some advantages and disadvantages:

#### Advantages

* More options, could find a library that has the right trade-off between simplicity/configurability/performance/integrability that you want.
* Often less conservative about making changes so more likely to take risks and experiment.
* Does more opinionated things about more specific operations.

#### Disadvantages

* Code isn't as rigorously checked, so is more likely(but not always) to be less secure, less performant, less consistent.
* Code will most likely be much less well documented so it can be harder to find what you want.
These are just guidelines and there definitely are exceptional community made libraries but you should take care. Also libraries in Rust are called crates; the pun is that we are using cargo to ship crates :p . For our project, we are going to use the fastrand crate since it is very simple and fast and we don't need the bells and whistles of other crates. To do this, we open our project folder and open the 'Cargo.toml' file in a text editor. Inside you will see this:
What we want to do is add under the [dependencies] line a new line that says
Different crates have different versions so it is always good to specify what version of the crate we want to avoid confusion. Now if we run using cargo, we can see it will take a bit longer to compile since it has to download and compile the fastrand crate and all the crates it uses. It will still run the same since we haven't used fastrand for anything yet.
Using it is dead easy though, let's add a function that creates a random maths question:
We use ranges to get the values for the fastrand::i32 function, between -50 and 50 inclusive. fastrand::bool just returns a boolean with equal odds. Now we can use this in our main function to generate the question:
And now when we run it, we get random questions as we want!
Next: Full annotated source code and possible extensions
# Rust for the Novice Programmer/Basic Maths Testing Program/Source Code and Extensions
## Full Source Code

Possible extensions you could try to implement, in order from easy to hard with some hints:
* Ask multiple questions in one run of the program(maybe use a for loop to run the code inside the main function a certain number of times)
* When asking multiple questions, add a counter that tracks how many of the questions the user got correct and print out what percentage they got correct
* Add multiplication and division to the operators(note you will need to change all the spots the operator is used) also you will need to change the number type for division if you want to handle that, although this may have more problems since what do you do about 1 divided by 3 since the resulting decimal will be 0.3333333333 which the user can't be expected to put in. Also make sure you handle division by 0 since that would cause problems. There are a lot of things to consider so this may be quite difficult if you want 'proper' division but integer division is an easier thing to implement.
* Track the time it takes the user to answer each question. It is suggested you use the standard library Instant struct to track the time. You can then print out the mean, median or other statistical measures. It is also suggested to use a Vec to store the times.
* Create more complicated maths questions with random numbers of operators in a single question. This is quite complicated for reasons that may be quite obscure with the Rust knowledge you have now but will be elaborated later. You may also want to put brackets between formulas
Please don't feel obligated to do these, only do them if you think it's interesting and you're having fun. You may easily run into issues that you don't know how to solve because of limited knowledge that will be covered later. The best advice is to read and try to understand compiler errors, maybe searching them if you're not sure for more context. Move on when you've had enough.
Next:
# Rust for the Novice Programmer
## Rust for the Novice Programmer

This is a guide to the Rust programming language for people who have little to no experience with programming in any language.
If you do have experience programming in other languages, other resources such as the official Rust Book may be more useful for you, as this book will try to explain a lot of basic programming concepts and ideas that may already be familiar to you.
With that, here's a basic introduction to programming and Rust!
Contents
* The basics
** Introduction
** Getting set up
** Hello World!
** Numbers
** Variables
** Comments
** Numbers and data types
** Functions
** If statements and booleans
** Loops and Iteration
** Arrays and Vectors
** Number Conversions
** Tuples and Structs
** Enums
** Pattern Matching
** Basics of References and borrowing
** Strings
* First program – Basic Maths Program
** Getting Started
** Traits and Displaying
** User Input
** Converting a String to a Number
** Checking the Numbers
** Randomness and External Crates
** Full Source Code and Potential Extensions
* Introduction - Simple CSV Analysis Program
* Misc things
# Rust for the Novice Programmer/Basic Maths Testing Program
## Basic Maths Testing Program

The best way to learn is to do!
Let's get stuck in with a program so we can logic around.

### The program specification

* The program will print out a simple maths question and the user answers it.
* It will be a command line program which means that it all happens in the terminal. This is opposed to a GUI program which may be what you're more used which are programs that use GUIs(Graphical User Interfaces).
* The maths question will be just a simple addition or subtraction at first.
There is more planning we could do but for now, let's get stuck in.
# Rust for the Novice Programmer/Basic Maths Testing Program/Checking the Numbers
## Checking the numbers

Now, we wish to verify whether the number the user inputted is equal to the result of the operator on the two numbers. First, let's calculate the number. To do this, it makes sense to have the two numbers and the operator as part of a struct, since those 3 values are all used together often and it is convenient to have them all together so we can define functions on the struct for cleaner code. Let's define the struct like so:
Often with structs, it is convenient to define a new function that makes it convenient to construct the struct. We can do this like so:
Note that since the names of the variables are the same as the names of the fields in the struct, we don't need to write out
This is a nice convenience. Also we are using implicit return with no semicolon, so we don't need to write return.
Now we can change our print_question function to be a method on this new struct, so we add the following function inside the impl MathsQuestion block:
Now we can write a function on the MathsQuestion struct to calculate the result, this function is again inside the impl MathsQuestion block:
And now we can change our main function to:
And now it works! If we enter 12(which is 35 - 23) we get the correct message, if we enter any other number we get the incorrect message!
Next: We make the generated numbers random using external crates
# Star Fox Adventures

Star Fox Adventures is a part of the Star Fox series. It was the last game developed by Rare Ltd. for a Nintendo console, before Microsoft fully bought out the company to become a first-party developer for the Xbox line of game consoles. Star Fox Adventures is the third game in the series, succeeding Star Fox 64, and features action-adventure gameplay unlike any Star-Fox title before it, but instead like The Legend of Zelda: Ocarina of Time.
General Scales starts causing havoc on Dinosaur Planet. Krystal tries to fight them, gets hurt, sends a distress beacon, Star Fox receives the distress signal and comes to help.

## Table of contents

* Gameplay
** Controls
* Items
* Bosses
** Galdon
** RedEye King
** Drakor
** General Scales
** Andross
* Dinosaur Planet
* Walkthrough
* Krystal
* Starting with Fox
* Rescuing Tricky
* The Queen's Peril
* The First Gatekeeper
* DarkIce Mines
* Returning the First SpellStone
* The Second Krazoa Spirit
* Journey to Cape Claw
* CloudRunner Fortress
* Returning the Second SpellStone
* The Third Krazoa Spirit
* Walled City
* Returning the Third SpellStone
* The Fourth Krazoa Spirit
* Dragon Rock
* Returning the Last SpellStone
* The Fifth Krazoa Spirit
* Final Battle
# Star Fox Adventures/Controls

| Control | Action | Description |
| Start | Communicator | Pauses the game. |
| Control Stick | Walk/Jog/Run/Aim | Move Fox/Krystal/Dinosaurs around; tilt it slightly to walk and farther to run. Aim Staff Weapons. Look around in First-Person View. |
| A | Action Button | Use Staff in combat; activate a Sidekick Command; use an item; talk to a Dinosaur |
| B | Cancel Button | Putting staff away, canceling Sidekick Command, exiting inventory |
| C-Stick | Inventory | Tilt left or right to access a section, and tilt up or down to scroll through the options of that section. |
| X | Avoid | Triggers an evasive action depending on your situation. (Forward roll during exploration and various flips and rolls in combat.) |
| Y | Assign item/action from Inventory | A blank button that you can assign an item/action from the invenory to for immediate access. Press this button when an item/action in the inventory is highlighted to assign it to that button. |
| Z | First-Person View | Look at the environment from your character's perspective. |
| L | Camera Control/Sidestep Mode | Press lightly to center the camera behind your character. Hold it down until it clicks to enter sidestep mode. |
| R | Defend | Trigger a defensive force-field during exploration; Block frontal enemy attacks during combat. |
| D-Pad | P.D.A. Display | Display maps, information, and a fuel-cell compass. |

## Arwing

These should be familiar if you've played Star Fox 64 (Lylat Wars if you live in other countries than the US).
| Control | Action |
| Start | Pauses the game. |
| Control Stick | Moves the arwing. Up to dive and down to climb. |
| A | Fires the Lasers |
| B | Fires a bomb but only if a bomb upgrade has been located within the level. |
| X | Hold to break. |
| Y | Hold to add turbo to your Arwing for a brief period. |
| L | Hold lightly to bank the Arwing and press hard to do a barrel roll. |
| R | Hold lightly to bank the Arwing and press hard to do a barrel roll. |
# Star Fox Adventures/Walkthrough

This walkthrough will take you through many things in your journey to bring the planet back together again by doing many things you might not expect to do. Here's a few things to get you started:
* There's no jump button. Instead, your characters automatically performs a jump.
* Going through items is easy thanks to the C-Stick.
* Useful upgrades for your staff.
* What to do to get the amount of gold rings to open up a portal to the mission you are after.
Also consider the important things you need on your quest:
* Buy all maps so your heads up display will tell you where you are.
* Certain items in the store to help you go through barriers.
* Fuel cells so you can fly through space to another location.
* Keep Tricky fully active with blue GrubTubs.
* Certain ways to beat both normal and Krazoa challenges.
# Star Fox Adventures/Walkthrough/DarkIce Mines
## Piloting to the Mines

You will need to pass through three gold rings to open the force field to DarkIce Mines. Fail to do so would require you to do it again.

## The lava pit

The Arwing will land at the bottom of a lava pit. There are two paths out of the pit: one in front of the Arwing and one behind it. It doesn't matter which one you choose because they will soon converge, and the path will narrow dramatically. At that point, you might want to walk instead of run. Be careful of fireballs shooting from the lava and the numerous gaps (including a hidden one where the bridge will collapse on contact) that are scattered across the trail.

## The gap in the path

Have Tricky dig a tunnel through the pile of snow that is blocking the entrance to shed on the left side of the trail. Destroy the two SharpClaws inside to get rid of the red barrier, and press the A button while in front of the newly-revealed container to open it. There is a Shackle Key inside. Use it to free the shackled SnowHorn outside of the shed. She will ask that you help Belina Te, Garunda Te's daughter, and she will give you a Bridge Cog, an item that she discovered during her captivity.
Continue along the path, and you'll come across a small gorge with a river flowing at its bottom. Climb down the stones on the far left, and cross the wooden dock at the bottom to the machine behind the waterfall. Place the bridge cog where indicated by a C-Stick, raise the lever on the left with the A button, and a bridge will appear across the gorge.
# Star Fox: Assault/Unlockables

The more Vs. mode matches that are played, the more options are opened up.