What distinguishes a School of Tomorrow affiliate is a focus on some shared focal points. One of which is the Concentric Hierarchy of Polyhedrons with their tetravolumes.
The source code below was cut and pasted from repl.it (prounounced "repplit"), a cloud-based training arena. See Literature below.
"""
From David Koski's paper:
Revisiting R.B. Fuller's S & E Modules
--------
The concentric hierarchy can be described in terms of
phi-scaled S modules:
Tetrahedron: 21S + 5s3 = 5S3 + 1S = 1S6 + 1S3
Skew Icosa: 60S + 20s3
Cube : 72S + 15s3 = 15S3 + 3S = 3S6 + 3S3
Octahedron : 84S + 20s3 = 20S3 + 4S = 4S6 + 4S3
Rh Triac : 105S + 25s3 = 25S3 + 5S = 5S6 + 5S3 (volume = 5)
Rh Dodec : 126S + 30s3 = 30S3 + 6S = 6S6 + 6S3
Pent Dodeca: 348E + 84e3
Icosahedron: 100E3 + 20E
VE : 20; 420S + 100s3
SuperRT : 20 * Syn3; 480E + 120e3
--------
On-line: http://coffeeshopsnet.blogspot.com/2017/06/koski-paper.html
"""
from math import sqrt as rt2
φ = (rt2(5)+1)/2 # golden ratio
Syn3 = rt2(9/8) # not to be confused with Smod
Smod = (φ**-5) / 2 # home base Smod
smod3 = Smod * φ**-3 # small s, phi down
Smod3 = Smod * φ**3 # capital s, phi up
Smod6 = Smod3 * φ**3 # phi up yet again
Cubocta = 20
SuperRT = Syn3 * Cubocta
Emod3 = SuperRT / 120 # Emod phi up
Emod = (rt2(2) / 8) * (φ**-3) # home base Emod
emod3 = Emod * φ**-3 # Emod phi down
S_factor = Smod / Emod # 2*sqrt(7-3*sqrt(5))
T_factor = pow(3/2, 1/3) * rt2(2) / φ
Tmod = 1/24
FiveVEs = 480 * Smod + 280 * smod3
Icosa = 100 * Emod3 + 20 * Emod
P_Dodeca = 348 * Emod + 84 * emod3
FiveOctas = 132 * Smod + 36 * smod3
RD = 6 * Smod6 + 6 * Smod3
RT5plus = 120 * Emod
RT5 = 5 * Smod6 + 5 * Smod3
Octa = 4 * Smod6 + 4 * Smod3
Cube = 3 * Smod6 + 3 * Smod3
SmallVE = Cubocta * 1/8 # half D edges (=R)
SkewIcosa = 60 * Smod + 20 * smod3
Tetra = 5 * Smod3 + Smod
print("Shape Volume Check")
print(f"Five VEs : {FiveVEs:10.6f}")
print(f"SuperRT : {SuperRT:10.6f}")
print(f"Cubocta : {Cubocta:10.6f}")
print(f"Icosa : {Icosa:10.6f} {20 * 1/S_factor:10.6f}")
print(f"P Dodeca : {P_Dodeca:10.6f}")
print(f"Five Octas : {FiveOctas:10.6f}")
print(f"Rh Dodeca (RD): {RD:10.6f}")
print(f"RT5+ : {RT5plus:10.6f} {SuperRT * φ**-3:10.6f}")
print(f"RT5 : {RT5:10.6f} {120 * Tmod:10.6f}")
print(f"Octa : {Octa:10.6f}")
print(f"Cube : {Cube:10.6f}")
print(f"Skew Icosa : {SkewIcosa:10.6f} {SmallVE * S_factor**2:10.6f}")
print(f"Small VE : {SmallVE:10.6f}")
print(f"Tetra : {Tetra:10.6f}")
print("-" * 20)
print(f"Emod3 : {Emod3:10.6f}")
print(f"Emod : {Emod:10.6f}")
print(f"emod3 : {emod3:10.6f}")
Smod_check = (Octa - SkewIcosa) / 24
print(f"Tmod : {Emod * (1 / T_factor**3):10.6f}")
print(f"Smod6 : {Smod6:10.6f}")
print(f"Smod3 : {Smod3:10.6f}")
print(f"Smod : {Smod:10.6f} {Smod_check:10.6f}")
print(f"smod3 : {smod3:10.6f}")
Shape Volume Check Five VEs : 24.620860 SuperRT : 21.213203 Cubocta : 20.000000 Icosa : 18.512296 18.512296 P Dodeca : 15.350018 Five Octas : 6.334369 Rh Dodeca (RD): 6.000000 RT5+ : 5.007758 5.007758 RT5 : 5.000000 5.000000 Octa : 4.000000 Cube : 3.000000 Skew Icosa : 2.917961 2.917961 Small VE : 2.500000 Tetra : 1.000000 -------------------- Emod3 : 0.176777 Emod : 0.041731 emod3 : 0.009851 Tmod : 0.041667 Smod6 : 0.809017 Smod3 : 0.190983 Smod : 0.045085 0.045085 smod3 : 0.010643
from IPython.display import YouTubeVideo
YouTubeVideo("gPcTl75Io5w")
YouTubeVideo("bD5RmyeN2LI")
ZomeZone -- lets look at even more modules, why not?
Our Jupyter Notebook's kernel is Python. The code cells you see, interspersed with text and pictures, are a primary constituent of the Jupyter Notebook. You will learn more about Jupyter Notebook technology as you work through these materials.
It's time for a short Glossary, that we will add to over time:
glossary = {} # empty dictionary (a set of key:value pairs) glossary.update({ "Jupyter Notebook (JN)" : "like a web page, but interactive, stored as json", "cell" : "a Jupyter Notebook consists of mostly Code and Markdown cells", "code cell" : "where runnable code, interpreted by the Kernel, is displayed and color coded", "markdown cell" : "uses a markup called markdown to format the text cells in a Jupyter Notebook", "Python" : "a computer language from Holland (the Netherlands) that went viral", "Kernel" : "an interpreter, e.g. Python, ready to process JN code cells and return results", }) type(glossary) # ask about this object's type
The School of Tomorrow features Jupyter Notebook based explorations of datasets, with the aim of building up skills with a specific suite of tools (see below).
Our topics will include (but are not limited to):
Links to Portland, Oregon, Cascadia region, home of the Oregon Curriculum Network.
Martian Math is Science Fiction, as well as a bridge to STEM topics.
However, we look at more than science fiction.
Based on our The Home of Tomorrow theme, we take seriously the curious mathematics ensconced within American Transcendentalism in the form of "synergetic geometry", the Concentric Hierarchy of Polyhedrons especially, which features a flagship Tetrahedron of edges one, as a unit of volume.
import identities
from identities import volumes_table
volumes_table
Volumes | Comments | |
---|---|---|
Shapes | ||
SuperRT | 21.213203 | Emods RT phi-up, (Icosa, P Dodeca) |
Cubocta | 20.000000 | 12 balls around 1 |
Icosa | 18.512296 | Jitterbug first stop |
P Dodeca | 15.350018 | Icosahedron Dual |
Rh Dodeca | 6.000000 | Space-filler, ball domain, (Cube, Octa) |
RT5+ | 5.007758 | Radius = 1.0000 |
RT5 | 5.000000 | Radius = 0.9994 |
Octa | 4.000000 | Jitterbug 2nd stop, Cube dual |
Cube | 3.000000 | Duo-tet cube, Octa dual |
Sm Icosa | 2.917961 | Faces flush with Octa |
Sm VE | 2.500000 | Faces flush with Octa |
Tetra | 1.000000 | Unit Volume |
Emod3 | 0.176777 | Emod phi up |
Emod | 0.041731 | 1/120th RT5+ |
emod3 | 0.009851 | Emod phi down |
Tmod | 0.041667 | 1/120th RT5 |
Amod | 0.041667 | 12 left + 12 right = Tetra |
Bmod | 0.041667 | 48A + 48B = Octa |
Smod3 | 0.190983 | Smod phi up |
Smod | 0.045085 | Sm Icosa + 24 Smods = Octa |
smod3 | 0.010643 | Smod phi down |
Martian Math is also a new approach to some of the ideas in Synergetics: Explorations in the Geometry of Thinking.
This is The School of Tomorrow after all. We teach the Bucky stuff.
Graphics by Richard Hawkins (see Grunch/Synergetics/Modules)
A modules make a Tetrahedron:
B modules with A modules, make an Octahedron. Tetrahedrons + Octahedrons define the space-filling IVM:
The MITE (minimum tetrahedron) is a space-filling tetrahedron, but not the only one (cite Sommerville):
The Coupler is an octahedral space-filler, also Unit Volume (same volume as Tetrahedron):
Maybe you would like to teach this curriculum it too?
Here are some slides you could use.
YouTubeVideo("ACnA3YknrT0") # https://youtu.be/ACnA3YknrT0
RSA is the name of a public key cryptography algorithm we study a lot. Cryptography involves a lot of what we might call Number Theory.
With the rise of the commercial web came the business requirement to perform secure communications, meaning encrypted communications over TCP/IP. The need for public key cryptography became obvious and widely disseminated, over the objections of those wishing to preserve "military grade" encryption for a chosen few.
Subsequent to the rise of the commercial web came the crypto-currencies revolution, and blockchain strategies for decentralizing the responsibility for securing transactions. The promise of these technologies led many more people to develop fluency around cryptography.
In periods marked by hostility towards specific cultures, the signature technologies of those cultures may be deprecated, pushed to the back burner. For example, some argue that Number Theory, pioneered by Friedrich Gauss (1777-1855), was given a lower profile in North American curricula because of hostility towards Germanic cultures.
The code cells are usually full of Python source code, ready to run. Even if the libraries we're using are such as numpy
and pandas
, the language we're sharing here is known as Python, named for Monty Python, the English comedy troupe.
When you first boot into Python, in order to use it coversationally, such as in a console, or in a code cell, it probably has no knowledge of time
as a topic, nor of datetime
nor math
-- these being the names of modules we might import.
Expect to use the proleptic Gregorian calendar in the Standard Library, or maybe the Julian ("when in Rome..."). You will also have integer days from an epochal starting point as an option, with time slices down to the nanosecond in pandas.
Seek 3rd party packages for other calendars. The Python ecosystem is well stocked.
import time
from datetime import date
# defining a type of object, of which we may have any number
# anyone gets to be a me
class Me(): # used below, to encapalsupate person data
def __init__(self, nm : str, dob : str):
self.name = nm
struct = time.strptime(dob, '%d %B %Y')
self.dob = date(*struct[:3])
def __repr__(self):
return "Me('{}', '{}')".format(
self.name,
self.dob.strftime("%d %B %Y"))
YouTubeVideo("apACNr7DC_s")
# all-star cast
bucky = Me("R. Buckminster Fuller", "12 July 1895")
gauss = Me("Carl Friedrich Gauss", "30 April 1777" )
wolfram = Me("Stephen Wolfram", "29 August 1959")
guido = Me("Guido van Rossum", "31 January 1956")
curie = Me("Marie Curie", "7 November 1867")
disney = Me("Walt Disney", "5 December 1901")
# suggestive of what we might store in JSON (or other format)
scenarios = {"RBF": bucky, "CFG": gauss, "WOLF": wolfram,
"GvR": guido, "MC": curie, "WD": disney} # dict with Me type values
for person in scenarios:
print("{:5} {}".format(person, scenarios[person]))
RBF Me('R. Buckminster Fuller', '12 July 1895') CFG Me('Carl Friedrich Gauss', '30 April 1777') WOLF Me('Stephen Wolfram', '29 August 1959') GvR Me('Guido van Rossum', '31 January 1956') MC Me('Marie Curie', '07 November 1867') WD Me('Walt Disney', '05 December 1901')
import json
def to_json(obj):
return [obj.name, obj.dob.strftime("%d %B %Y")]
with open("timelines.json", "w") as target:
json.dump(scenarios, target, default=to_json)
Let's keep building that glossary...
# alternative syntax for adding to a Python dictionary
glossary["HTTP"] = "hypertext transfer protocol"
glossary["TLS"] = "Transport Layer Security, used to turn HTTP into HTTPS"
glossary["RSA"] = "public key crypto algorithm, named for collaborators Rivest, Shamir, Adleman"
glossary["PGP"] = "Pretty Good Privacy, RSA before the US patent expired, by Phil Zimmerman"
At the time of this writing, the Silicon Forest continued to honor the memory of Linus Pauling by preserving his boyhood home on Hawthorne Boulevard. The organization supporting these preservation efforts was the Institute for Science, Engineering and Public Policy.
Do engineers live by a code of ethics? Should they? ISEPP, a think tank, was looking into these questions, especially in light of Linus and Ava Helen Pauling's teachings and values.
YouTubeVideo("UpEJysjcLBY")
By the early 21st Century, many schools were using various Jupyter Notebook like tools. One of most impressive was SAGE, which allowed cloud computing including access to computer algebra systems.
The edu-sig archives at Python.org is a good place to search for insights into how some high school and college teachers were using such tools, including of course Jupyter Notebooks.
Jupyter Notebooks may be rendered in several ways:
Check out this notebook in nbviewer!
Of the above, the first option is the most preferred, because "interactive" means only "the ability to edit and run code cells" where "cell" means some rectangle of code or text, such as you are reading now (if reading a Jupyter Notebook).
If you're running Jupyter Notebook on localhost, you'll be able to start new notebooks from scratch, as well as completely overhaul the ones in your personal stash.
The Oregon Curriculum Network is not a retailer or direct marketer of educational supplies. When you visit your medical doctor, you may get a prescription for a specific pill, but you buy those pills from a pharmacy not directly from the doctor. The doctor may give you free samples in some cases.
Some of you are teachers and are planning on adapting Oregon Curriculum Network materials for your own use.
Toys might include construction kits such as Zometool and Lux Blox.
glossary.update({
"CSV" : "comma-separated values, one of the simplest data sharing formats",
"DOM" : "the Document Object Model is a tree of graph of a document in a web browser",
"HTML" : "hypertext markup language, almost an XML, defines the DOM in tandem with CSS",
"JavaScript" : "a computer language, not confined to running inside browsers but happy there",
"Pascal" : "an early computer language, later commercially available as Delphi from Borland",
"json" : "JavaScript Object Notation is a way to save data (compare with XML)",
"localhost" : "the IP address of the host computer: 127.0.0.1",
"port" : "internet services connect through IP:port addresses, JN usually on port 8888",
"web browser" : "HTTP client, sends requests, gets responses",
"web server" : "accepts and processes (or rejects) HTTP requests, sends responses",
"XML" : "a markup language using pointy brackets, reminiscent of HTML, for structured data",
"SGML" : "a parent specification behind what eventually became XML"
})
Python is a language of objects, where objects have type or kind, species. Depending on the species of an object, it will have varying capabilities. Dog objects bark. Car objects brake. Python is one of many computer languages we consider "object oriented".
HTML didn't come out of nowhere. Imagine storing all the parts for an airplane in a computer. How would you do that. JSON is one answer. XML is another. XML grew out of an older SGML where ML stands for "markup language". In HTML, we use pointy brackets as a kind of punctuation.
The poet Gene Fowler used to say we should teach HTML right along with all the rest of the language, meaning periods, commas, semi-colons and like that (grammar and punctuation). He wrote a text processor in Pascal showing the kind of thing he meant. He was a prisoner in San Quentin before he discovered how to "re-genius" himself.
We'll be sharing a lot of data sets in this school. We consume data produced by others, and we publish data for others to use.
Data needs to be stored in some structured way, in files and databases. Even pictures, movies and music are data. We package up data in files and stream these files to one another over the internet or by some other means. Computer programs are also stored as data files, usually in some standard text encoding such as UTF-8.
In the Glossary above, created in the Python language as a "dictionary", you will find at least three data storing and streaming formats defined: CSV, JSON and XML.
The above data structure looks a lot like JSON by the way. Let's see that using Python's json library:
import json # Python has a huge library with hundreds of modules
send_over_web = json.dumps(glossary)
print(send_over_web[:50], "...", send_over_web[-10:]) # first 50 chars is enough, then the last 10.
{"Jupyter Notebook (JN)": "like a web page, but in ... came XML"}
type(send_over_web) # what type of object is this? Number? String? Other kind of object? Dog?
str
We just asked to have our glossary
object turned into a string (a sequence of characters, like keyboard characters), but formatted as JSON. That ended up looking not much different from the glossary
object in the first place, as defined in the code cell above.
When a web browser asks an IP:port address for an HTTP response, by means of an HTTP request, it may get back JSON as payload. Or it may get back HTML, its bread and butter. Web browsers are all about combining the HTML + CSS in an HTTP response, and turning that into a formatted and typeset looking web page, such as you're likely looking at right now.
Lets save our JSON as a text file, for retrieval in a next notebook.
with open('glossary.json', 'w') as output:
json.dump(glossary, output)
Lets continue to build or sense of how to slice and dice time using a much trickier coordinate system than most. Keeping track of date and time is non-trivial. Our tools took many programmer hours to build. Keep looking for bugs.
Remember that some concepts we seek to track, such as whether daylight savings time, or standard time is in effect, may depend on datasets we have not updated recently.
from datetime import timedelta # for time deltas (needed for size deltas)
for person in scenarios.values():
# cent = person.dob + timedelta(days=365 * 100) <-- tempting but wrong
cent = date(person.dob.year + 100, person.dob.month, person.dob.day)
print("Name: {:20} DOB: {} Centennial: {}".format(
person.name, person.dob, cent))
Name: R. Buckminster Fuller DOB: 1895-07-12 Centennial: 1995-07-12 Name: Carl Friedrich Gauss DOB: 1777-04-30 Centennial: 1877-04-30 Name: Stephen Wolfram DOB: 1959-08-29 Centennial: 2059-08-29 Name: Guido van Rossum DOB: 1956-01-31 Centennial: 2056-01-31 Name: Marie Curie DOB: 1867-11-07 Centennial: 1967-11-07 Name: Walt Disney DOB: 1901-12-05 Centennial: 2001-12-05
# help(timedelta)