Superstrings are a genralization of normal strings - all the same axioms but on a larger class of objects.
A superstring (unlike a normal string of symbols like "abc")
can hhave holes in it -- some subscripts are missing:
- (1+>"a" | 3+>"c") is a super string.
- For Sets A, finite A, super(A)::= Nat<>->A
- For A, elements(A)::=Nat><A.
- For x: super(A), end(x)::Nat= if(x={}, 0, max(pre(x)) ).
- For x,y:super(A), x!y::@(Nat,A)= x | y(_+end(x)).
- (above)|-MONOID( super(A), (!), {}).
- |()- (monoid) #A==>super(A).
- |()- super(A) generated_by elements(A).
- (above)|-Unique factorisation!
- For all x:super(A), x={} or for one e:element(A), y:super(A), x=e!y.
So define ... first(x)....rest(x)...last(x)...,
As always we have
- |-For P,Q:@super(X), x!P, P!x, P!Q are defined and in @super(A).
We have a typical induction schema:
- SUPER_INDUCTION::=
- |-SUPER_INDUCTION.
We can reduce a superstring to just the elements in a subset of the
natural numbers:
- For N:@Nat, x:super(A), N!x::=N;x.
- (above)|-N!x={ i+>a || i:N and (i+>a) in x }.
. . . . . . . . . ( end of section SuperStrings) <<Contents | End>>
Replace Nat by Positive Real,
- hyper(A)::= { x: Real<>->A || one lub(x) and one glb(x) },
- end(x)::=lub(pre(x)),
...
. . . . . . . . . ( end of section HyperStrings) <<Contents | End>>
- histories(A)::= { x: Real<>->bag(A) || one lub(x) and one glb(x) },
- end(x)::=lub(pre(x)),
...
- For x,y:histories(A), x!y::@(Real,bag(A))= { (t,e) || t in pre(x)|pre(y) and e=x(t)+y(t) }.
. . . . . . . . . ( end of section histories) <<Contents | End>>
A is any set.
T is any set
S is a subset of @T such that each set t in S has a special maximum value
+ is an associative operation that preserves maximum values
the sum of two T's is greater than the max of them
S conatins all the finite subsets of T.
supergenstring=S<>->A.
. . . . . . . . . ( end of section Super-general) <<Contents | End>>
Special characters are defined in
[ intro_characters.html ]
that also outlines the syntax of expressions and a document.
Proofs follow a natural deduction style that start with
assumptions ("Let") and continue to a consequence ("Close Let")
and then discard the assumptions and deduce a conclusion. Look
here
[ Block Structure in logic_25_Proofs ]
for more on the structure and rules.
The notation also allows you to create a new network of variables
and constraints. A "Net" has a number of variables (including none) and
a number of properties (including none) that connect variables.
You can give them a name and then reuse them. The schema, formal system,
or an elementary piece of documentation starts with "Net" and finishes "End of Net".
For more, see
[ notn_13_Docn_Syntax.html ]
for these ways of defining and reusing pieces of logic and algebra
in your documents. A quick example: a circle
might be described by
Net{radius:Positive Real, center:Point, area:=π*radius^2, ...}.
For a complete listing of pages in this part of my site by topic see
[ home.html ]
The notation used here is a formal language with syntax
and a semantics described using traditional formal logic
[ logic_0_Intro.html ]
plus sets, functions, relations, and other mathematical extensions.
For a more rigorous description of the standard notations
see
- STANDARD::= See http://www.csci.csusb.edu/dick/maths/math_11_STANDARD.html
- above::reason="I'm too lazy to work out which of the above statements I need here", often the last 3 or 4 statements.
The previous and previous but one statments are shown as (-1) and (-2).
- given::reason="I've been told that...", used to describe a problem.
- given::variable="I'll be given a value or object like this...", used to describe a problem.
- goal::theorem="The result I'm trying to prove right now".
- goal::variable="The value or object I'm trying to find or construct".
- let::reason="For the sake of argument let...", introduces a temporary hypothesis that survives until the end of the surrounding "Let...Close.Let" block or Case.
- hyp::reason="I assumed this in my last Let/Case/Po/...".
- QED::conclusion="Quite Easily Done" or "Quod Erat Demonstrandum", indicates that you have proved what you wanted to prove.
- QEF::conclusion="Quite Easily Faked", -- indicate that you have proved that the object you constructed fitted the goal you were given.
- RAA::conclusion="Reducto Ad Absurdum". This allows you to discard the last
assumption (let) that you introduced.