Mark/handouts
Mark/handouts
1
0
Fork 0
Code Pull Requests 2 Actions Packages Releases Activity

Compare commits

merge into: Mark:main
Branches Tags
Mark:main
Mark:relativity
Mark:tropical-fix
Mark:typos
Mark:attribution
Mark:quake
Mark:master-old
...
pull from: Mark:master-old
Branches Tags
Mark:relativity
Mark:main
Mark:tropical-fix
Mark:typos
Mark:attribution
Mark:quake
Mark:master-old

No commits in common. "main" and "master-old" have entirely different histories.
main ... master-old

63 changed files with 3435 additions and 1812 deletions
Show Stats Expand all files Collapse all files

6
.github/workflows/ci.yml vendored
View File

@ -2,8 +2,6 @@ name: CI
on: on:
push: push:
branches:
- main
pull_request: pull_request:
workflow_dispatch: workflow_dispatch:
@ -91,7 +89,7 @@ jobs:
retention-days: 7 retention-days: 7
- name: "Publish package (hash)" - name: "Publish package (hash)"
if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/main' }} if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/master' }}
run: | run: |
PUBLISH_USER="${{ secrets.PUBLISH_USER }}" \ PUBLISH_USER="${{ secrets.PUBLISH_USER }}" \
PUBLISH_KEY="${{ secrets.PUBLISH_KEY }}" \ PUBLISH_KEY="${{ secrets.PUBLISH_KEY }}" \
@ -100,7 +98,7 @@ jobs:
python tools/scripts/publish.py python tools/scripts/publish.py
- name: "Publish package (latest)" - name: "Publish package (latest)"
if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/main' }} if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/master' }}
run: | run: |
PUBLISH_USER="${{ secrets.PUBLISH_USER }}" \ PUBLISH_USER="${{ secrets.PUBLISH_USER }}" \
PUBLISH_KEY="${{ secrets.PUBLISH_KEY }}" \ PUBLISH_KEY="${{ secrets.PUBLISH_KEY }}" \

3
.vscode/settings.json vendored
View File

@ -1,5 +1,4 @@
{ {
"latex-workshop.latex.recipe.default": "latexmk (xelatex)", "latex-workshop.latex.recipe.default": "latexmk (xelatex)",
"tinymist.formatterPrintWidth": 80, "tinymist.formatterPrintWidth": 80
"tinymist.typstExtraArgs": ["--package-path=./lib/typst"]
} }

674
LICENSE Normal file
View File

@ -0,0 +1,674 @@
GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The GNU General Public License is a free, copyleft license for
software and other kinds of works.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users. We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors. You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.
To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights. Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received. You must make sure that they, too, receive
or can get the source code. And you must show them these terms so they
know their rights.
Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.
For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software. For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.
Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so. This is fundamentally incompatible with the aim of
protecting users' freedom to change the software. The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable. Therefore, we
have designed this version of the GPL to prohibit the practice for those
products. If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.
Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary. To prevent this, the GPL assures that
patents cannot be used to render the program non-free.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU General Public License.
"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy. The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
1. Source Code.
The "source code" for a work means the preferred form of the work
for making modifications to it. "Object code" means any non-source
form of a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
The Corresponding Source for a work in source code form is that
same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force. You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright. Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under
the conditions stated below. Sublicensing is not allowed; section 10
makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
b) The work must carry prominent notices stating that it is
released under this License and any conditions added under section
7. This requirement modifies the requirement in section 4 to
"keep intact all notices".
c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided
you inform other peers where the object code and Corresponding
Source of the work are being offered to the general public at no
charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling. In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage. For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product. A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source. The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed. Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or
requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or
authors of the material; or
e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions of
it) with contractual assumptions of liability to the recipient, for
any liability that these contractual assumptions directly impose on
those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term. If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or
run a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all. For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
13. Use with the GNU Affero General Public License.
Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work. The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation. If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.
If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
Also add information on how to contact you by electronic and paper mail.
If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:
<program> Copyright (C) <year> <name of author>
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
<https://www.gnu.org/licenses/>.
The GNU General Public License does not permit incorporating your program
into proprietary programs. If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with
the library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License. But first, please read
<https://www.gnu.org/licenses/why-not-lgpl.html>.

156
README.md Normal file
View File

@ -0,0 +1,156 @@
# ORMC Handouts
This repository contains all the handouts I've written for the [ORMC](https://circles.math.ucla.edu/circles/). \
You can find the latest PDFs [here](https://static.betalupi.com/ormc).
**For my students:** Handouts will appear here a few days before class. Please don't look at them (or their solutions) beforehand, that spoils all the fun!
**For everyone else:** If you are not affiliated with the ORMC, ask for permission before using these.
## 📦 Contents
Handouts are sorted by the class they're for:
- [`./Intermediate`](./Intermediate/): Grades 5 - 9
- [`./Advanced`](./Advanced): Grades 9 - 12
Grade levels are estimates.
## 🛠️ Building these Handouts
Automatic builds are [here](https://static.betalupi.com/ormc), if you just want the PDFs.
If you want to edit these files, you'll need to download a custom document class. \
To compile one handout, do the following:
1. Download the handout's directory (i.e, download the whole repo as a zip and extract the folder you want.)
1. Download [`./resources/ormc_handout.cls`](./resources/ormc_handout.cls)
2. Put this class in the same directory as the handout.
3. Fix the include path at the top of the handout.
Usually, you'll need to replace
```latex
\documentclass[
...
]{../../../lib/tex/ormc_handout}
```
with
```latex
\documentclass[
...
]{ormc_handout}
```
These documents should work with any LaTeX engine. \
However, try changing your engine to LuaLaTeX if something breaks.
---------------------------------------------------------------------------
# 📜 Class Documentation
The class `ormc_handout` is based on `article.cls`, and should work with most LaTeX packages. It has everything you need and nothing you don't; it looks pretty and it is optimized for greyscale printing.
If you find something broken, please tell me so I may try to fix it.
## 🎏 Arguments
These are passed to `\documentclass`, as follows:
```latex
% Documentclass argument example
\documentclass[
nosolutions,
shortwarning
]{ormc_handout}
```
- `10pt`, `11pt`, `12pt`:\
Default: `10pt`. Sets font size.
- `pagenumber`, `nopagenumber`:\
Default: `pagenumber`. Shows or hides page numbers.
- `solutions`, `nosolutions`:\
Default: `solutions`\
If `nosolutions` is passed, `solution` and `instructornote` environments are hidden.
- `showwarning`, `hidewarning`:\
Default: `showwarning`. Shows or hides instructor handout warning.
- `shortwarning`, `longwarning`:\
Default: `longwarning`. Sets instructor handout warning type.
- `multinumbering`, `singlenumbering`:\
Default: `multinumbering`\
How problems, theorems, etc should be numbered. If `mulitnumbering` is passed, problems, theorems, etc will be numbered independently. If `singlenumbering` is passed, one global counter will be used. (I think `singlenumering` is better, it makes the handout easier to navigate.)
Use `geometry` to change page lengths. Letter paper is the default.
## 🪖 Commands & More:
`ormc_handout` automatically includes `tcolorbox`, `xcolor`, `tikz`, `amsmath`, `amssymb`. \
It also includes a few other packages that are used internally and shouldn't have an effect on most workflows.
### **Basics:**
- `\say{text}`: Puts text in quotes, handling details like period spacing. Courtesy of `dirtytalk`.
- `\tab`: Typewriter-style tabs every `1cm`. Courtesy of `tabto`.
- `\maketitle`: Makes a title. This is never placed on a separate page.
- Set title data with the following commands:\
`\title{text}`, `\subtitle{text}`, `\uptitlel{text}`, `\uptitler{text}`\
`\uptitlel` and `\uptitler` are optional, but usually come together.
- `\note[Type]{text}`: Makes a note.
- `\hint{text}`: Shorthand for `\note[Hint]{text}`
### **Sectioning:**
The usual LaTeX title-customization techniques *WILL NOT WORK* with this class.\
Don't even try to load `titlesec`.
- `\section{title}<label>`: Creates a section with an optional label.\
You do not need to include the angle brackets.\
If you do, you can reference this section with `\ref{label}`.
- `\definition{title}<label>`: Makes a definition. Works just like `\section`.
- `\proposition{title}<label>`: Makes a proposition. Works just like `\section`.
- `\theorem{title}<label>`: Makes a theorem. Works just like `\section`.
- `\example{title}<label>`: Makes an example. Works just like `\section`.
- `\problem{title}<label>`: Makes a problem. Works just like `\section`.
- `\problempart{title}<label>`: Makes a problem part. Works just like `\section`.\
As the name implies, this command should only be used to make subparts of `\problems`.\
This command may be removed in the future.
- `\generic{title}<label>`: Makes a generic section. Works just like `\section`.\
Avoid using this if you can. \
Generic sections have no counter, and are usually used to get text to look the same as a section title. \
This command may be removed in the future.
### **Environments:**
- `\begin{solution}`: A fancy `tcolorbox` for solutions to problems. \
This is hidden if the `nosolutions` flag is passed.
- `\begin{instrutornote}`: A fancy `tcolorbox` for instructor notes. \
This is hidden if the `nosolutions` flag is passed.
- `\begin{examplesolution}`: A fancy `tcolorbox` for sample solutions. \
This is never hidden.
All the above environments break across pages and may be safely nested.
Each also has a special command `\linehack`, which draws a line across the box.\
Use `\linehack` instead of `tcolorbox` sections. `tcolorbox` only lets you have two, while `\linehack` gives you as many as you want.

71
lib/typst/local/handout/0.1.0/header.typ
View File

@ -1,71 +0,0 @@
#import "misc.typ": ored
#let solution_warning() = {
set text(ored)
align(
center,
block(
width: 60%,
height: auto,
breakable: false,
fill: rgb(255, 255, 255),
stroke: ored + 2pt,
inset: 3mm,
(
align(center, text(weight: "bold", size: 12pt, [Instructor's Handout]))
+ parbreak()
+ align(
left,
text(
size: 10pt,
[
This handout contains solutions and notes. \
Recompile without solutions before distributing.
],
),
)
),
),
)
}
#let make_header(
title,
subtitle: none,
by: none,
top_left: "",
top_right: "",
) = {
let date = datetime
.today()
.display("[month repr:long] [day padding:none], [year]")
if (by != none) {
by = text(size: 10pt, [Prepared by #by on #date])
}
// Main title
align(
center,
block(
width: 60%,
height: auto,
breakable: false,
align(
center,
stack(
spacing: 7pt,
// Top
text(size: 10pt, top_left) + h(1fr) + text(size: 10pt, top_right),
line(length: 100%, stroke: 0.2mm),
// Title
text(size: 20pt, title),
// Subtitle
if (by != none) { text(size: 10pt, by) },
if (subtitle != none) { text(size: 10pt, subtitle) },
line(length: 100%, stroke: 0.2mm),
),
),
),
)
}

113
lib/typst/local/handout/0.1.0/lib.typ
View File

@ -1,113 +0,0 @@
/// Typst handout library, used for all documents in this repository.
// Re-exports
// All functions that maybe used by client code are listed here
#import "misc.typ": *
#import "object.typ": problem, definition, theorem
#import "solution.typ": if_solutions, if_no_solutions, solution
/// Main handout wrapper.
/// Use this as follows:
///
/// ```
/// #show: handout.with(
/// group: "Advanced 2",
/// title: [Handout Title],
/// by: "author",
/// subtitle: "optional",
/// )
///
/// <rest of document>
/// ```
#let handout(
doc,
group: none,
title: none,
by: none,
subtitle: none,
) = {
set page(
margin: 20mm,
width: 8.5in,
height: 11in,
footer: align(
center,
context counter(page).display(),
),
footer-descent: 5mm,
)
//
// Text style
set text(font: "New Computer Modern")
set par(
leading: 0.55em,
first-line-indent: 0mm,
justify: true,
spacing: 0.5em,
)
//
// List style
show list: set block(spacing: 0.5em, below: 1em)
set list(
tight: false,
indent: 5mm,
spacing: 3mm,
)
//
// Heading style
set heading(numbering: (..nums) => nums.pos().at(0))
show heading.where(level: 1): it => {
set align(center)
set text(weight: "bold")
block[
Section #counter(heading).display(): #text(it.body)
]
}
//
// Hack for custom references
show ref: it => {
import "object.typ": ref_obj
let x = ref_obj(it) // Custom impl for object references
if (x != none) { return x }
return it // Use default `ref` implementation otherwise
}
//
// Begin content
//
// Make handout title
{
import "header.typ": make_header, solution_warning
import "solution.typ": show_solutions
let url = link(
"https://betalupi.com/handouts",
`betalupi.com/handouts`,
)
make_header(
title,
subtitle: subtitle,
by: by,
top_left: group,
top_right: url,
)
if show_solutions {
solution_warning()
}
}
// Include rest of document
doc
}

49
lib/typst/local/handout/0.1.0/misc.typ
View File

@ -1,49 +0,0 @@
/// Miscellaneous utilities
#let ored = rgb("D62121")
#let oorange = rgb("#ffaa3b")
#let ogrape = rgb("9C36B5")
#let ocyan = rgb("2288BF")
#let oteal = rgb("12B886")
#let ogreen = rgb("37B26D")
#let oblue = rgb("1C7ED6")
#let note(content, type: none) = {
set text(fill: rgb(100, 100, 100))
if type != none {
text(style: "oblique", [#type: ])
}
text(content)
}
#let hint = note.with(type: "Hint")
#let examplesolution(content) = {
let c = oblue
align(
center,
stack(
block(
width: 100%,
breakable: false,
fill: c,
stroke: c + 2pt,
inset: 1.5mm,
(
align(left, text(fill: white, weight: "bold", [Example solution:]))
),
),
block(
width: 100%,
height: auto,
breakable: false,
fill: c.lighten(80%).desaturate(10%),
stroke: c + 2pt,
inset: 3mm,
align(left, content),
),
),
)
}

100
lib/typst/local/handout/0.1.0/object.typ
View File

@ -1,100 +0,0 @@
/// This module defines all handout "objects"
/// (problems, theorems, definitions, etc)
/// Core render code for all objects (problems, theorems, etc)
/// This should never be used directly by client code.
///
/// Args:
/// - kind: the kind of object to make ("Problem", "Definition", etc)
/// - label_name: a string. If provided, generate metadata for this object
/// under the given label. Labels must be unique.
/// This label can then be used to reference this object.
///
/// For example:
/// ```
/// #problem(label: "problem1")
/// This is @problem1
/// ```
#let _obj_base(kind, ..args, label_name: none) = {
counter("obj").step()
let n = context counter("obj").get().first()
// The complete title text of this object,
// like "Problem 5:" or "Theorem: "
let obj_content = if args.pos().len() == 0 {
[#kind #n:]
} else {
[#kind #n: #args.pos().at(0)]
}
// Render the object
block(
above: 8mm,
below: 2mm,
text(weight: "bold", obj_content),
)
// Generate labeled metadata for this object.
//
// This can be viewed directly with `#context query(<label>).first().value`,
// Or referenced with `@label` (we define a custom renderer for this metadata later)
if label_name != none {
let meta = (
"obj_meta_ref_kind": kind,
// "obj_content": obj_content,
"label": label(label_name),
"counter": counter("obj"),
)
[ #metadata(meta) #label(label_name) ]
}
}
// `ref` implementation for object meta-references.
// Returns `none` if `it` is not object metadata.
#let ref_obj(it) = {
let magic_key = "obj_meta_ref_kind"
if not (
it.element != none
and it.element.has("value")
and type(it.element.value) == "dictionary"
and it.element.value.keys().contains(magic_key)
) {
// This label is not attached to object metadata
return none
}
let v = it.element.value
let obj_type = v.at(magic_key)
// The value of this object's counter at its label
let obj_count = v.counter.at(v.label).first()
// Produces text like "Problem 2",
// which takes you to the referenced object when clicked.
return link(v.label, [#obj_type #obj_count])
}
/// Factory function for objects.
/// Provided for convenience, lets us define objects in one line.
#let _mkobj(kind) = {
let out(..args, label: none) = _obj_base(
kind,
..args,
label_name: label,
)
return out
}
//
// MARK: export
//
// Functions for client code are defined below
#let problem = _mkobj("Problem")
#let definition = _mkobj("Definition")
#let theorem = _mkobj("Theorem")
#let example = _mkobj("Example")
#let remark = _mkobj("Remark")

56
lib/typst/local/handout/0.1.0/solution.typ
View File

@ -1,56 +0,0 @@
#import "misc.typ": ored
/// If false, hide instructor info.
///
/// Compile with the following command to hide solutions:
/// `typst compile main.typ --input show_solutions=false`
///
/// Solutions are shown by default. This behavior
/// is less surprising than hiding content by default.
#let show_solutions = {
if "show_solutions" in sys.inputs {
// Show solutions unless they're explicitly disabled
not (
sys.inputs.show_solutions == "false" or sys.inputs.show_solutions == "no"
)
} else {
// Show solutions by default
true
}
}
#let if_solutions(content) = {
if show_solutions { content }
}
#let if_no_solutions(content) = {
if not show_solutions { content }
}
#let solution(content) = {
if_solutions(
align(
center,
stack(
block(
width: 100%,
breakable: false,
fill: ored,
stroke: ored + 2pt,
inset: 1.5mm,
align(left, text(fill: white, weight: "bold", [Solution:])),
),
block(
width: 100%,
height: auto,
breakable: false,
fill: ored.lighten(80%).desaturate(10%),
stroke: ored + 2pt,
inset: 3mm,
align(left, content),
),
),
),
)
}

12
lib/typst/local/handout/0.1.0/typst.toml
View File

@ -1,12 +0,0 @@
[package]
name = "handout"
description = "A library for math circle handouts"
version = "0.1.0"
entrypoint = "lib.typ"
homepage = "https://betalupi.com/handouts"
repository = "https://git.betalupi.com/Mark/handouts"
authors = ["Mark <mark@betalupi.com>"]
license = "GPL-3.0-only "
disciplines = ["education", "mathematics"]
categories = ["layout", "components"]

280
src/Advanced/Tropical Polynomials/handout.typ Executable file
View File

@ -0,0 +1,280 @@
/// If false, hide instructor info.
///
/// Compile with the following command to hide solutions:
/// `typst compile main.typ --input show_solutions=false`
///
/// Solutions are shown by default. This behavior
/// is less surprising than hiding content by default.
#let show_solutions = {
if "show_solutions" in sys.inputs {
// Show solutions unless they're explicitly disabled
not (
sys.inputs.show_solutions == "false" or sys.inputs.show_solutions == "no"
)
} else {
// Show solutions by default
true
}
}
// Colors
#let ored = rgb("D62121")
#let ogrape = rgb("9C36B5")
#let ocyan = rgb("2288BF")
#let oteal = rgb("12B886")
#let ogreen = rgb("37B26D")
#let oblue = rgb("1C7ED6")
//
// MARK: header
//
#let make_title(
group,
quarter,
title,
subtitle,
) = {
align(
center,
block(
width: 60%,
height: auto,
breakable: false,
align(
center,
stack(
spacing: 7pt,
(
text(size: 10pt, group) + h(1fr) + text(size: 10pt, quarter)
),
line(length: 100%, stroke: 0.2mm),
(
text(size: 20pt, title) + linebreak() + text(size: 10pt, subtitle)
),
line(length: 100%, stroke: 0.2mm),
),
),
),
)
}
#let warn = {
set text(ored)
align(
center,
block(
width: 60%,
height: auto,
breakable: false,
fill: rgb(255, 255, 255),
stroke: ored + 2pt,
inset: 3mm,
(
align(center, text(weight: "bold", size: 12pt, [Instructor's Handout]))
+ parbreak()
+ align(
left,
text(
size: 10pt,
[This handout contains solutions and notes.]
+ linebreak()
+ [Recompile without solutions before distributing.],
),
)
),
),
)
}
#let preparedby(name) = (
text(
size: 10pt,
[Prepared by ]
+ name
+ [ on ]
+ datetime
.today()
.display("[month repr:long] [day padding:none], [year]"),
)
)
//
// MARK: Solutions
//
#let solution(content) = {
if show_solutions {
align(
center,
stack(
block(
width: 100%,
breakable: false,
fill: ored,
stroke: ored + 2pt,
inset: 1.5mm,
(
align(left, text(fill: white, weight: "bold", [Solution:]))
),
),
block(
width: 100%,
height: auto,
breakable: false,
fill: ored.lighten(80%).desaturate(10%),
stroke: ored + 2pt,
inset: 3mm,
align(left, content),
),
),
)
}
}
#let notsolution(content) = {
if not show_solutions { content }
}
//
// MARK: Sections
//
#let generic(t) = block(
above: 8mm,
below: 2mm,
text(weight: "bold", t),
)
#let _generic_base(kind, ..args) = {
counter("obj").step()
if args.pos().len() == 0 {
generic([
#kind
#context counter("obj").display():
])
} else {
generic(
[
#kind
#context counter("obj").display():
]
+ " "
+ args.pos().at(0),
)
}
}
#let problem(..args) = _generic_base("Problem", ..args)
#let definition(..args) = _generic_base("Definition", ..args)
#let theorem(..args) = _generic_base("Theorem", ..args)
//
// MARK: Misc
//
#let hint(content) = {
text(fill: rgb(100, 100, 100), style: "oblique", "Hint: ")
text(fill: rgb(100, 100, 100), content)
}
#let note(content) = {
text(fill: rgb(100, 100, 100), content)
}
#let examplesolution(content) = {
let c = oblue
align(
center,
stack(
block(
width: 100%,
breakable: false,
fill: c,
stroke: c + 2pt,
inset: 1.5mm,
(
align(left, text(fill: white, weight: "bold", [Example solution:]))
),
),
block(
width: 100%,
height: auto,
breakable: false,
fill: c.lighten(80%).desaturate(10%),
stroke: c + 2pt,
inset: 3mm,
align(left, content),
),
),
)
}
//
// MARK: wrapper
//
#let handout(
doc,
group: none,
quarter: none,
title: none,
by: none,
subtitle: none,
) = {
set par(leading: 0.55em, first-line-indent: 0mm, justify: true)
set text(font: "New Computer Modern")
set par(spacing: 0.5em)
show list: set block(spacing: 0.5em, below: 1em)
set heading(numbering: (..nums) => nums.pos().at(0))
set page(
margin: 20mm,
width: 8.5in,
height: 11in,
footer: align(
center,
context counter(page).display(),
),
footer-descent: 5mm,
)
set list(
tight: false,
indent: 5mm,
spacing: 3mm,
)
show heading.where(level: 1): it => {
set align(center)
set text(weight: "bold")
block[
Section #counter(heading).display(): #text(it.body)
]
}
make_title(
group,
quarter,
title,
{
if by == none { none } else { [#preparedby(by)\ ] }
if subtitle == none { none } else { subtitle }
},
)
if show_solutions {
warn
}
doc
}

2
src/Advanced/Tropical Polynomials/macros.typ
View File

@ -1,4 +1,4 @@
#import "@local/handout:0.1.0": * #import "./handout.typ": *
#import "@preview/cetz:0.3.1" #import "@preview/cetz:0.3.1"

11
src/Advanced/Tropical Polynomials/main.typ
View File

@ -1,6 +1,13 @@
#import "@local/handout:0.1.0": * #import "./handout.typ": *
#show: doc => handout(
doc,
group: "Advanced 2",
quarter: link(
"https://betalupi.com/handouts",
"betalupi.com/handouts",
),
#show: handout.with(
title: [Tropical Polynomials], title: [Tropical Polynomials],
by: "Mark", by: "Mark",
subtitle: "Based on a handout by Bryant Mathews", subtitle: "Based on a handout by Bryant Mathews",

2
src/Advanced/Tropical Polynomials/meta.toml
View File

@ -3,5 +3,5 @@ title = "Tropical Polynomials"
[publish] [publish]
handout = false handout = true
solutions = true solutions = true

11
src/Advanced/Tropical Polynomials/parts/00 arithmetic.typ
View File

@ -1,4 +1,4 @@
#import "@local/handout:0.1.0": * #import "../handout.typ": *
#import "../macros.typ": * #import "../macros.typ": *
= Tropical Arithmetic = Tropical Arithmetic
@ -62,7 +62,8 @@ Let's expand $#sym.RR$ to include a tropical additive identity.
#problem() #problem()
Do tropical additive inverses exist? \ Do tropical additive inverses exist? \
#note([ #note([
Is there an inverse $y$ for every $x$ so that $x #tp y = #sym.infinity$? Is there an inverse $y$ for every $x$ so that $x #tp y = #sym.infinity$? \
Remember that $#sym.infinity$ is the additive identity.
]) ])
#solution([ #solution([
@ -104,7 +105,7 @@ Is there a tropical multiplicative identity? \
Do tropical multiplicative inverses always exist? \ Do tropical multiplicative inverses always exist? \
#note([ #note([
For every $x != #sym.infinity$, does there exist an inverse $y$ so that $x #tm y = i$, \ For every $x != #sym.infinity$, does there exist an inverse $y$ so that $x #tm y = i$, \
where $i$ is the multiplicative identity? where $i$ is the additive identity?
]) ])
#solution([Yes, it is $-x$. For $x != 0$, $x #tm (-x) = 0$]) #solution([Yes, it is $-x$. For $x != 0$, $x #tm (-x) = 0$])
@ -126,7 +127,7 @@ Fill the following tropical addition and multiplication tables
#let col = 10mm #let col = 10mm
#if_no_solutions( #notsolution(
table( table(
columns: (1fr, 1fr), columns: (1fr, 1fr),
align: center, align: center,
@ -277,7 +278,7 @@ Fill the following tropical addition and multiplication tables
#problem() #problem()
Expand and simplify $f(x) = (x #tp 2)(x #tp 3)$, then evaluate $f(1)$ and $f(4)$ \ Expand and simplify $f(x) = (x #tp 2)(x #tp 3)$, then evaluate $f(1)$ and $f(4)$ \
Adjacent parenthesis imply tropical multiplication #hint([Adjacent parenthesis imply tropical multiplication])
#solution([ #solution([
$ $

25
src/Advanced/Tropical Polynomials/parts/01 polynomials.typ
View File

@ -1,4 +1,4 @@
#import "@local/handout:0.1.0": * #import "../handout.typ": *
#import "../macros.typ": * #import "../macros.typ": *
#import "@preview/cetz:0.3.1" #import "@preview/cetz:0.3.1"
@ -20,7 +20,7 @@ for some nonnegative integer $n$ and coefficients $c_0, c_1, ..., c_n$. \
The _degree_ of a polynomial is the largest $n$ for which $c_n$ is nonzero. The _degree_ of a polynomial is the largest $n$ for which $c_n$ is nonzero.
#theorem() #theorem()
The _fundamental theorem of algebra_ implies that any non-constant polynomial with real coefficients The _fundamental theorem of algebra_ states that any non-constant polynomial with real coefficients
can be written as a product of polynomials of degree 1 or 2 with real coefficients. can be written as a product of polynomials of degree 1 or 2 with real coefficients.
#v(2mm) #v(2mm)
@ -30,8 +30,8 @@ can be written as $(x^2 + 2x+5)(x-2)(x+4)(x+4)$
#v(2mm) #v(2mm)
A similar theorem exists for polynomials with complex coefficients. \ A similar theorem exists for polynomials with complex coefficients. \
These coefficients may be found using the roots of this polynomial. \ These coefficients may be found using the _roots_ of this polynomial. \
As it turns out, there are formulas that determine the roots of quadratic, cubic, and quartic #note([(degree 2, 3, and 4)]) polynomials. There are no formulas for the roots of polynomials with larger degrees---in this case, we usually rely on approximate roots found by computers. As you already know, there are formulas that determine the roots of quadratic, cubic, and quartic #note([(degree 2, 3, and 4)]) polynomials. There are no formulas for the roots of polynomials with larger degrees---in this case, we usually rely on appropriate roots found by computers.
#v(2mm) #v(2mm)
In this section, we will analyze tropical polynomials: In this section, we will analyze tropical polynomials:
@ -63,7 +63,7 @@ where all exponents represent repeated tropical multiplication.
Draw a graph of the tropical polynomial $f(x) = x^2 #tp 1x #tp 4$. \ Draw a graph of the tropical polynomial $f(x) = x^2 #tp 1x #tp 4$. \
#hint([$1x$ is not equal to $x$.]) #hint([$1x$ is not equal to $x$.])
#if_no_solutions(graphgrid(none)) #notsolution(graphgrid(none))
#solution([ #solution([
$f(x) = min(2x , 1+x, 4)$, which looks like: $f(x) = min(2x , 1+x, 4)$, which looks like:
@ -100,7 +100,7 @@ In other words, find $r$ and $s$ so that
), ),
) )
we will call $r$ and $s$ the _roots_ of $f$. #note([Naturally, we will call $r$ and $s$ the _roots_ of $f$.])
#solution([ #solution([
Because $(x #tp r)(x #tp s) = x^2 #tp (r #tp s)x #tp s r$, we must have $r #tp s = 1$ and $r #tm s = 4$. \ Because $(x #tp r)(x #tp s) = x^2 #tp (r #tp s)x #tp s r$, we must have $r #tp s = 1$ and $r #tm s = 4$. \
@ -116,7 +116,8 @@ we will call $r$ and $s$ the _roots_ of $f$.
#v(1fr) #v(1fr)
#problem() #problem()
How can we use the graph to determine these roots? Can you see the roots of this polynomial in the graph? \
#hint([Yes, you can. What "features" do the roots correspond to?])
#solution([The roots are the corners of the graph.]) #solution([The roots are the corners of the graph.])
@ -132,7 +133,7 @@ How can we use the graph to determine these roots?
Graph $f(x) = -2x^2 #tp x #tp 8$. \ Graph $f(x) = -2x^2 #tp x #tp 8$. \
#hint([Use half scale. 1 box = 2 units.]) #hint([Use half scale. 1 box = 2 units.])
#if_no_solutions(graphgrid(none)) #notsolution(graphgrid(none))
#solution([ #solution([
#graphgrid({ #graphgrid({
@ -140,7 +141,7 @@ Graph $f(x) = -2x^2 #tp x #tp 8$. \
let step = 0.75 let step = 0.75
dotline((0, 0), (8 * step, 8 * step)) dotline((0, 0), (8 * step, 8 * step))
dotline((0.5 * step, 0), (4.5 * step, 8 * step)) dotline((0.5 * step, 0), (4 * step, 8 * step))
dotline((0, 4 * step), (8 * step, 4 * step)) dotline((0, 4 * step), (8 * step, 4 * step))
line( line(
@ -210,7 +211,7 @@ and always produces $7$ for sufficiently large inputs.
#problem() #problem()
Graph $f(x) = 1x^2 #tp 3x #tp 5$. Graph $f(x) = 1x^2 #tp 3x #tp 5$.
#if_no_solutions(graphgrid(none)) #notsolution(graphgrid(none))
#solution([ #solution([
The graphs of all three terms intersect at the same point: The graphs of all three terms intersect at the same point:
@ -261,7 +262,7 @@ How are the roots of $f$ related to its coefficients?
#problem() #problem()
Graph $f(x) = 2x^2 #tp 4x #tp 4$. Graph $f(x) = 2x^2 #tp 4x #tp 4$.
#if_no_solutions(graphgrid(none)) #notsolution(graphgrid(none))
#solution( #solution(
graphgrid({ graphgrid({
@ -316,7 +317,7 @@ into linear factors.
#v(2mm) #v(2mm)
Whenever we say "the roots of $f$", we really mean "the roots of $accent(f, macron)$." \ Whenever we say "the roots of $f$", we really mean "the roots of $accent(f, macron)$." \
$f$ and $accent(f, macron)$ might be the same polynomial. Also, $f$ and $accent(f, macron)$ might be the same polynomial.
#problem() #problem()
If $f(x) = a x^2 #tp b x #tp c$, then $accent(f, macron)(x) = a x^2 #tp B x #tp c$ for some $B$. \ If $f(x) = a x^2 #tp b x #tp c$, then $accent(f, macron)(x) = a x^2 #tp B x #tp c$ for some $B$. \

20
src/Advanced/Tropical Polynomials/parts/02 cubic.typ
View File

@ -1,16 +1,16 @@
#import "@local/handout:0.1.0": * #import "../handout.typ": *
#import "../macros.typ": * #import "../macros.typ": *
#import "@preview/cetz:0.3.1" #import "@preview/cetz:0.3.1"
= Tropical Cubic Polynomials = Tropical Cubic Polynomials
#problem() #problem()
Consider the polynomial $f(x) = x^3 #tp 1x^2 #tp 3x #tp 6$. \ Consider the polynomial $f(x) = x^3 #tp x^2 #tp 3x #tp 6$. \
- sketch a graph of this polynomial - sketch a graph of this polynomial
- use this graph to find the roots of $f$ - use this graph to find the roots of $f$
- write (and expand) a product of linear factors with the same graph as $f$. - write (and expand) a product of linear factors with the same graph as $f$.
#if_no_solutions(graphgrid(none)) #notsolution(graphgrid(none))
#solution([ #solution([
- Roots are 1, 2, and 3. - Roots are 1, 2, and 3.
@ -43,12 +43,12 @@ Consider the polynomial $f(x) = x^3 #tp 1x^2 #tp 3x #tp 6$. \
#pagebreak() // MARK: page #pagebreak() // MARK: page
#problem() #problem()
Consider the polynomial $f(x) = x^3 #tp 1x^2 #tp 6x #tp 6$. \ Consider the polynomial $f(x) = x^3 #tp x^2 #tp 6x #tp 6$. \
- sketch a graph of this polynomial - sketch a graph of this polynomial
- use this graph to find the roots of $f$ - use this graph to find the roots of $f$
- write (and expand) a product of linear factors with the same graph as $f$. - write (and expand) a product of linear factors with the same graph as $f$.
#if_no_solutions(graphgrid(none)) #notsolution(graphgrid(none))
#solution([ #solution([
- Roots are 1, 2.5, and 2.5. - Roots are 1, 2.5, and 2.5.
@ -82,7 +82,7 @@ Consider the polynomial $f(x) = x^3 #tp 6x^2 #tp 6x #tp 6$. \
- use this graph to find the roots of $f$ - use this graph to find the roots of $f$
- write (and expand) a product of linear factors with the same graph as $f$. - write (and expand) a product of linear factors with the same graph as $f$.
#if_no_solutions(graphgrid(none)) #notsolution(graphgrid(none))
#solution([ #solution([
- Roots are 2, 2, and 2. - Roots are 2, 2, and 2.
@ -118,10 +118,10 @@ Using the last three problems, find formulas for $B$ and $C$ in terms of $a$, $b
#solution([ #solution([
$ $
B = min(b, (a+c)/2, (2a+d)/3) B = min(b, (a+c)/2, (2a+d)/2)
$ $
$ $
C = min(c, (b+d)/2, (a+2d)/3) C = min(c, (b+d)/2, (a+2d)/2)
$ $
]) ])
@ -153,7 +153,7 @@ What are the roots of the following polynomial?
#v(1fr) #v(1fr)
#pagebreak() // MARK: page #pagebreak() // MARK: page
#problem(label: "findci") #problem()
If If
$ $
f(x) = c_0 #tp c_1 x #tp c_2 x^2 #tp ... #tp c_n x^n f(x) = c_0 #tp c_1 x #tp c_2 x^2 #tp ... #tp c_n x^n
@ -183,7 +183,7 @@ Find a formula for each $C_i$ in terms of $c_0, c_1, ..., c_n$.
#problem() #problem()
With the same setup as @findci, \ With the same setup as the previous problem, \
find formulas for the roots $r_1, r_2, ..., r_n$. find formulas for the roots $r_1, r_2, ..., r_n$.
#solution([ #solution([

35
src/Warm-Ups/A Familiar Concept/main.tex Executable file
View File

@ -0,0 +1,35 @@
\documentclass[
solutions,
hidewarning,
singlenumbering,
nopagenumber
]{../../../lib/tex/ormc_handout}
\usepackage{../../../lib/tex/macros}
\title{Warm-Up: A Familiar Concept}
\uptitler{\smallurl{}}
\subtitle{Prepared by Mark on \today}
\begin{document}
\maketitle
\problem{}<one>
Let $v = [-5, -2, 0, 1, 4, 1000]$. Find all $x$ that minimize the following metric. \par
$$
\sum_{\forall i} |v_i - x| = |v_1 - x| + |v_2 - x| + ... + |v_6 - x|
$$
\vfill
\problem{}
Let $v = [-5, -2, 0, 1, 4, 1000, 1001]$. Find all $x$ that minimize the metric in \ref{one}.
\vfill
\problem{}
What is this metric usually called?
\end{document}

33
src/Warm-Ups/A Familiar Concept/main.typ
View File

@ -1,33 +0,0 @@
#import "@local/handout:0.1.0": *
#show: handout.with(
title: [Warm-Up: A Familiar Concept],
by: "Mark",
)
#problem()
Let $v = [-5, -2, 0, 1, 4, 1000]$. Find all $x$ that minimize the following metric:
#align(
center,
box(
inset: 3mm,
$
sum_(#sym.forall i) |v_i - x| = |v_1 - x| + |v_2 - x| + ... + |v_6 - x|
$,
),
)
#v(1fr)
#problem()
Let $v = [-5, -2, 0, 1, 4, 1000, 1001]$. Find all $x$ that minimize the metric in the previous problem.
#v(1fr)
#problem()
What is this metric usually called?
#v(0.25fr)

93
src/Warm-Ups/Adders/main.tex Executable file
View File

@ -0,0 +1,93 @@
\documentclass[
nosolutions,
singlenumbering,
nopagenumber
]{../../../lib/tex/ormc_handout}
\usepackage{../../../lib/tex/macros}
\title{Warm-Up: Adders}
\uptitler{\smallurl{}}
\subtitle{Prepared by Mark on \today}
\begin{document}
\maketitle
\problem{}
Fill the following binary addition table. \par
\hint{s is \say{sum,} c is \say{carry}}
\begin{center}
\begin{tabular}{ c c || c c }
$a$ & $b$ & s & c \\
\hline
0 & 0 & ? & ? \\
0 & 1 & ? & ? \\
1 & 0 & ? & ? \\
1 & 1 & ? & ?
\end{tabular}
\end{center}
\vfill
\problem{}
Draw a logic circuit that atisfies the above table. \par
This is called a \textit{half adder}. \par
\hint{You should need exactly two gates.}
\begin{solution}
$s = a \texttt{ xor } b$ \par
$c = a \texttt{ and } b$
\end{solution}
\vfill
\definition{}
A \textit{full adder} is similar to a half adder, but it has an extra input: \par
a full adder takes $a$, $b$, and $c_\text{in}$, and produces $s$ and $c_\text{out}$. \par
\hint{$c_\text{in}$ is \say{carry in}}
\problem{}
Use two half adders to construct a full adder.
\begin{solution}
$s_1, c_1 = \texttt{HA}(a, b)$ \par
$s_2, c_2 = \texttt{HA}(s_1, c_\text{in})$ \par
$s_\text{out} = s_2$ \par
$c_\text{out} = \texttt{OR}(c_1, c_2)$
\vspace{2mm}
Of course, the class should just draw the circuit.
\end{solution}
\vfill
\pagebreak
\problem{}<rippleadder>
How can we add two four-bit binary numbers using the full adder? \par
We want a four-bit output sum and a one-bit $c_\text{out}$.
\vfill
\problem{}
Say that all basic logic gates need $1u$ of time to fully switch states. \par
\note[Note]{This is called \textit{gate delay}}
\vspace{2mm}
How much time does a full adder need to fully switch states? \par
How about your circuit from \ref{rippleadder}?
\vfill
\problem{Bonus}
Design a faster solution to \ref{rippleadder}.
\vfill
\pagebreak
\end{document}

85
src/Warm-Ups/Adders/main.typ
View File

@ -1,85 +0,0 @@
#import "@local/handout:0.1.0": *
#show: handout.with(
title: [Warm-Up: Adders],
by: "Mark",
)
#problem()
Fill the following binary addition table. \
#hint([s is "sum," c is "carry"])
#align(
center,
table(
columns: (9mm, 9mm, 9mm, 9mm),
align: center,
$a$, $b$, $s$, $c$,
[0], [0], [?], [?],
[0], [1], [?], [?],
[1], [0], [?], [?],
[1], [1], [?], [?],
),
)
#v(1fr)
#problem()
Draw a logic circuit that atisfies the above table. \
This is called a _half adder_. \
#hint([You should need exactly two gates.])
#solution([
$s = a #text([`xor`]) b$ \
$c = a #text([`and`]) b$
])
#v(1fr)
#definition()
A _full adder_ is similar to a half adder, but it has an extra input: \
a full adder takes $a$, $b$, and $c_"in"$, and produces $s$ and $c_"out"$. \
#hint([$c_"in"$ is "carry in"])
#problem()
Use two half adders to construct a full adder.
#solution([
$
s_1, c_1 &= "HA"(a, b) \
s_2, c_2 &= "HA"(s_1, c_"in") \
s_"out" &= s_2 \
c_"out" &= "OR"(c_1, c_2)
$
#v(2mm)
Of course, the class should just draw the circuit.
])
#v(1fr)
#pagebreak()
#problem(label: "ripple-adder")
How can we add two four-bit binary numbers using the full adder? \
We want a four-bit output sum and a one-bit $c_"out"$.
#v(1fr)
#problem()
Say that all basic logic gates need $1u$ of time to fully switch states. \
#note([This is called _gate delay_], type: "Note")
#v(2mm)
How much time does a full adder need to fully switch states? \
How about your circuit from @ripple-adder?
#v(1fr)
#problem("Bonus")
Design a faster solution to @ripple-adder.
#v(1fr)

187
src/Warm-Ups/Big-Tac-Toe/main.tex Executable file
View File

@ -0,0 +1,187 @@
\documentclass[
solutions,
hidewarning,
singlenumbering,
nopagenumber
]{../../../lib/tex/ormc_handout}
\usepackage{../../../lib/tex/macros}
% x,y,scale,style
\def\ttt#1#2#3#4{
\draw[#4] (#1, #2+#3) -- (#1+#3+#3+#3, #2+#3);
\draw[#4] (#1, #2+#3+#3) -- (#1+#3+#3+#3, #2+#3+#3);
\draw[#4] (#1+#3, #2) -- (#1+#3, #2+#3+#3+#3);
\draw[#4] (#1+#3+#3, #2) -- (#1+#3+#3, #2+#3+#3+#3);
}
\geometry{
paper = letterpaper,
top = 25mm,
bottom = 30mm,
left = 20mm,
right = 20mm,
headheight = 75mm,
footskip = 15mm
}
% misere ttt
% Numerical Tic Tac Toe is a variation invented by the mathematician Ronald Graham.
% The numbers 1 to 9 are used in this game. The first player plays with the odd numbers,
% the second player plays with the even numbers. All numbers can be used only once.
% The player who puts down 15 points in a line wins (sum of 3 numbers).
% This game can be generalized to a n × n board.
% In Treblecross, both players play with the same symbol.
% The game is played on a 1-by-n board with k equal to 3.
% The player who makes a three in a row of Xs (or black chips) wins the game
\title{Warm-Up: Big-Tac-Toe}
\uptitler{\smallurl{}}
\subtitle{Prepared by Mark on \today.}
\begin{document}
\maketitle
We have large tic-tac-toe grid, each cell of which contains another.
On each turn, one player puts their glyph into a cell of a small grid. When the next player goes,
they must make their move in the small grid in the same position as the previous player's move.
\begin{itemize}
\item The first player to move may pick any small grid to start in.
\item If a player is directed to a grid that is \textit{full}, that player may go anywhere. \par
A sub-grid that is \say{won} but not full may still be played in.
\end{itemize}
\vspace{2mm}
The first player to complete a line of three \say{won} subgrids wins the game.
\vfill\null\hfill
\begin{minipage}{0.48\textwidth}
\begin{center}
\begin{tikzpicture}[scale=0.65]
\ttt{0}{0}{4}{line width=0.5mm}
\ttt{0.5}{0.5}{1}{line width=0.25mm}
\ttt{0.5}{4.5}{1}{line width=0.25mm}
\ttt{0.5}{8.5}{1}{line width=0.25mm}
\ttt{4.5}{0.5}{1}{line width=0.25mm}
\ttt{4.5}{4.5}{1}{line width=0.25mm}
\ttt{4.5}{8.5}{1}{line width=0.25mm}
\ttt{8.5}{0.5}{1}{line width=0.25mm}
\ttt{8.5}{4.5}{1}{line width=0.25mm}
\ttt{8.5}{8.5}{1}{line width=0.25mm}
\end{tikzpicture}
\end{center}
\end{minipage}
\hfill
\begin{minipage}{0.48\textwidth}
\begin{center}
\begin{tikzpicture}[scale=0.65]
\ttt{0}{0}{4}{line width=0.5mm}
\ttt{0.5}{0.5}{1}{line width=0.25mm}
\ttt{0.5}{4.5}{1}{line width=0.25mm}
\ttt{0.5}{8.5}{1}{line width=0.25mm}
\ttt{4.5}{0.5}{1}{line width=0.25mm}
\ttt{4.5}{4.5}{1}{line width=0.25mm}
\ttt{4.5}{8.5}{1}{line width=0.25mm}
\ttt{8.5}{0.5}{1}{line width=0.25mm}
\ttt{8.5}{4.5}{1}{line width=0.25mm}
\ttt{8.5}{8.5}{1}{line width=0.25mm}
\end{tikzpicture}
\end{center}
\end{minipage}
\hfill\null\vfill
\problem{}
Play a few rounds of this game with someone nearby. \par
Can either player force a win?
\vfill
\problem{}
Modify the rules of this game to disallow play in won subgrids. \par
How does your strategy change?
\vfill
\pagebreak
\null\vfill\null\hfill
\begin{minipage}{0.48\textwidth}
\begin{center}
\begin{tikzpicture}[scale=0.65]
\ttt{0}{0}{4}{line width=0.5mm}
\ttt{0.5}{0.5}{1}{line width=0.25mm}
\ttt{0.5}{4.5}{1}{line width=0.25mm}
\ttt{0.5}{8.5}{1}{line width=0.25mm}
\ttt{4.5}{0.5}{1}{line width=0.25mm}
\ttt{4.5}{4.5}{1}{line width=0.25mm}
\ttt{4.5}{8.5}{1}{line width=0.25mm}
\ttt{8.5}{0.5}{1}{line width=0.25mm}
\ttt{8.5}{4.5}{1}{line width=0.25mm}
\ttt{8.5}{8.5}{1}{line width=0.25mm}
\end{tikzpicture}
\end{center}
\end{minipage}
\hfill
\begin{minipage}{0.48\textwidth}
\begin{center}
\begin{tikzpicture}[scale=0.65]
\ttt{0}{0}{4}{line width=0.5mm}
\ttt{0.5}{0.5}{1}{line width=0.25mm}
\ttt{0.5}{4.5}{1}{line width=0.25mm}
\ttt{0.5}{8.5}{1}{line width=0.25mm}
\ttt{4.5}{0.5}{1}{line width=0.25mm}
\ttt{4.5}{4.5}{1}{line width=0.25mm}
\ttt{4.5}{8.5}{1}{line width=0.25mm}
\ttt{8.5}{0.5}{1}{line width=0.25mm}
\ttt{8.5}{4.5}{1}{line width=0.25mm}
\ttt{8.5}{8.5}{1}{line width=0.25mm}
\end{tikzpicture}
\end{center}
\end{minipage}
\hfill\null\vfill
\vfill\null\hfill
\begin{minipage}{0.48\textwidth}
\begin{center}
\begin{tikzpicture}[scale=0.65]
\ttt{0}{0}{4}{line width=0.5mm}
\ttt{0.5}{0.5}{1}{line width=0.25mm}
\ttt{0.5}{4.5}{1}{line width=0.25mm}
\ttt{0.5}{8.5}{1}{line width=0.25mm}
\ttt{4.5}{0.5}{1}{line width=0.25mm}
\ttt{4.5}{4.5}{1}{line width=0.25mm}
\ttt{4.5}{8.5}{1}{line width=0.25mm}
\ttt{8.5}{0.5}{1}{line width=0.25mm}
\ttt{8.5}{4.5}{1}{line width=0.25mm}
\ttt{8.5}{8.5}{1}{line width=0.25mm}
\end{tikzpicture}
\end{center}
\end{minipage}
\hfill
\begin{minipage}{0.48\textwidth}
\begin{center}
\begin{tikzpicture}[scale=0.65]
\ttt{0}{0}{4}{line width=0.5mm}
\ttt{0.5}{0.5}{1}{line width=0.25mm}
\ttt{0.5}{4.5}{1}{line width=0.25mm}
\ttt{0.5}{8.5}{1}{line width=0.25mm}
\ttt{4.5}{0.5}{1}{line width=0.25mm}
\ttt{4.5}{4.5}{1}{line width=0.25mm}
\ttt{4.5}{8.5}{1}{line width=0.25mm}
\ttt{8.5}{0.5}{1}{line width=0.25mm}
\ttt{8.5}{4.5}{1}{line width=0.25mm}
\ttt{8.5}{8.5}{1}{line width=0.25mm}
\end{tikzpicture}
\end{center}
\end{minipage}
\hfill\null\vfill
\end{document}

90
src/Warm-Ups/Big-Tac-Toe/main.typ
View File

@ -1,90 +0,0 @@
#import "@local/handout:0.1.0": *
#import "@preview/cetz:0.3.1"
#show: handout.with(
title: [Warm-Up: Big-Tac-Toe],
by: "Mark",
)
#let extra_boards = false;
#let ttt(s, p) = {
// s: scale,
// p: position
let x = p.at(0) * s
let y = p.at(1) * s
cetz.draw.line((-1 * s + x, 3 * s + y), (-1 * s + x, -3 * s + y))
cetz.draw.line((1 * s + x, 3 * s + y), (1 * s + x, -3 * s + y))
cetz.draw.line((3 * s + x, -1 * s + y), (-3 * s + x, -1 * s + y))
cetz.draw.line((3 * s + x, 1 * s + y), (-3 * s + x, 1 * s + y))
}
#let btt(s) = cetz.canvas({
import cetz.draw: *
set-style(stroke: (thickness: 0.5mm * s))
ttt(s, (-7, -7))
ttt(s, (-7, 0))
ttt(s, (-7, 7))
ttt(s, (0, -7))
ttt(s, (0, 0))
ttt(s, (0, 7))
ttt(s, (7, -7))
ttt(s, (7, 0))
ttt(s, (7, 7))
set-style(stroke: (thickness: 2mm * s))
ttt(s * 3.5, (0, 0))
})
#problem()
Consider a large tic-tac-toe grid, each cell of which contains another.
On each turn, one player puts their glyph into a cell of a small grid. When the next player goes,
they must make their move in the small grid in the same position as the previous player's move.
- The first player to move may pick any small grid to start in.
- If a player is directed to a grid that is _full_, that player may go anywhere. \
A sub-grid that is "won" but not full may still be played in.
#v(2mm)
The first player to complete a line of three "won" subgrids wins the game.
#v(2mm)
#problem()
Play a few rounds of this game with someone nearby. \
Can either player force a win?
#table(
stroke: none,
align: center,
columns: (1fr, 1fr),
btt(0.35), btt(0.35),
);
#problem()
Modify the rules of this game to disallow play in won subgrids. \
How does your strategy change? \
#if extra_boards { note([Additional boards are available on the next page.]) }
#v(1fr)
#if extra_boards {
pagebreak()
align(
center,
grid(
stroke: none,
align: center,
columns: (1fr, 1fr),
rows: (1fr, 1fr, 1fr),
btt(0.35), btt(0.35),
btt(0.35), btt(0.35),
btt(0.35), btt(0.35),
),
)
}

31
src/Warm-Ups/Fuse Timers/main.tex Executable file
View File

@ -0,0 +1,31 @@
\documentclass[
solutions,
hidewarning,
singlenumbering,
nopagenumber
]{../../../lib/tex/ormc_handout}
\usepackage{../../../lib/tex/macros}
\title{Warm-Up: Fuse Timers}
\uptitler{\smallurl{}}
\subtitle{Prepared by Mark on \today.}
\begin{document}
\maketitle
\problem{}
Suppose we have two strings and a lighter. Each string takes an hour to fully burn. \par
However, we do not know how fast each part of the string burns:
half might burn in 1 minute, and the rest could take 59.
\vspace{2mm}
How would we measure exactly 45 minutes using these strings?
\vfill
\end{document}

15
src/Warm-Ups/Fuse Timers/main.typ
View File

@ -1,15 +0,0 @@
#import "@local/handout:0.1.0": *
#show: handout.with(
title: [Warm-Up: Fuse Timers],
by: "Mark",
)
#problem()
Suppose we have two strings and a lighter. Each string takes exactly an hour to fully burn. \
However, we do not know how fast each part of the string burns:
half might burn in 1 minute, and the rest could take 59.
#v(2mm)
How can we measure exactly 45 minutes using these two strings?

121
src/Warm-Ups/Gallery/main.tex Executable file
View File

@ -0,0 +1,121 @@
\documentclass[
solutions,
singlenumbering,
nopagenumber
]{../../../lib/tex/ormc_handout}
\usepackage{../../../lib/tex/macros}
\makeatletter
\newcommand{\thisone}{
\if@solutions
{\color{red} $\Leftarrow$ \texttt{this one}}
\else\fi
}
\title{Warm-Up: The Gallery}
\uptitler{\smallurl{}}
\subtitle{Prepared by Mark on \today}
\begin{document}
\maketitle
A museum curator is arranging seven photographs on a gallery wall in accordance with the photographer's requirements.
They are titled as follows: Fence, Gardenias, Hibiscus, Irises, Katydid, Lotus, and Magnolia.
The photograph's requirements are as follows:
\begin{itemize}
\item Gardenias must be immediately before Katydid.
\item Hibiscus must be somewhere before Katydid but cannot be the first photograph.
\item Irises and Lotus must be next to one another.
\item Magnolia must be one of the first three photographs.
\item Fence must be either first or seventh.
\end{itemize}
\problem{}
Which of the below could be a valid ordering? \par
\note[Note]{We denote each painting by the first letter of its title.}
\begin{itemize}
\item \texttt{FHGMKIL}
\item \texttt{HMGKILF}
\item \texttt{ILMHGKF} \thisone{}
\item \texttt{LMIHGKF}
\item \texttt{MFHGKLI}
\end{itemize}
\vfill
\problem{}
If Irises is immediately before Gardenias, which of the following could be true?
\begin{itemize}
\item Gardenias is fourth
\item Hibiscus is fourth
\item Irises is third
\item Lotus is second
\item Magnolia is third \thisone{}
\end{itemize}
\vfill
\problem{}
The ordering of the photographs is fully determined if...
\begin{itemize}
\item Gardenias is fourth
\item Hibiscus is second
\item Irises is second
\item Lotus is first \thisone{}
\item Magnolia is third
\end{itemize}
\vfill
\pagebreak
\problem{}
If Magnolia is second, what CANNOT be true?
\begin{itemize}
\item Hibiscus is third
\item Hibiscus is fourth \thisone{}
\item Hibiscus is fifth
\item Gardenias is fourth
\item Gardenias is sixth
\end{itemize}
\vfill
\problem{}
Katydid cannot be in which position?
\begin{itemize}
\item Third \thisone{}
\item Fourth
\item Fifth
\item Sixth
\item Seventh
\end{itemize}
\vfill
\problem{}
If Gardenias is fourth, what must be true?
\begin{itemize}
\item Fence is first \thisone{}
\item Hibiscus is third
\item Irises is seventh
\item Magnolia is first
\item Magnolia is second
\end{itemize}
\vfill
\problem{}
Which one of the following,
if substituted for the second condition,
would have the same effect in determining the
arrangement of the photographs?
\begin{itemize}
\item If Fence is seventh, Hibiscus is second
\item Gardenias is somewhere after Hibiscus, and either Fence or Magnolia is first
\item Hibiscus must be somewhere between the first and sixth photographs
\item Unless Hibiscus is second, it must be somewhere between Magnolia and Gardenias \thisone{}
\item Katydid is somewhere after Hibiscus, which must be after Fence.
\end{itemize}
\vfill
\pagebreak
\end{document}

103
src/Warm-Ups/Gallery/main.typ
View File

@ -1,103 +0,0 @@
#import "@local/handout:0.1.0": *
#show: handout.with(
title: [Warm-Up: The Gallery],
by: "Mark",
)
#let thisone = if_solutions(
text(fill: ored, [#sym.arrow.l.double.long `this one`]),
)
A museum curator is arranging seven photographs on a gallery wall in accordance with the photographer's requirements.
They are titled as follows: Fence, Gardenias, Hibiscus, Irises, Katydid, Lotus, and Magnolia.
The photograph's requirements are as follows:
#v(2mm)
- Gardenias must be immediately before Katydid.
- Hibiscus must be somewhere before Katydid but cannot be the first photograph.
- Irises and Lotus must be next to one another.
- Magnolia must be one of the first three photographs.
- Fence must be either first or seventh.
#problem()
Which of the below could be a valid ordering? \
#note([We denote each painting by the first letter of its title.], type: "Note")
- `FHGMKIL`
- `HMGKILF`
- `ILMHGKF` #thisone
- `LMIHGKF`
- `MFHGKLI`
#v(1fr)
#problem()
If Irises is immediately before Gardenias, which of the following could be true?
- Gardenias is fourth
- Hibiscus is fourth
- Irises is third
- Lotus is second
- Magnolia is third #thisone
#v(1fr)
#problem()
The ordering of the photographs is fully determined if...
- Gardenias is fourth
- Hibiscus is second
- Irises is second
- Lotus is first #thisone
- Magnolia is third
#v(1fr)
#pagebreak()
#problem()
If Magnolia is second, what CANNOT be true?
- Hibiscus is third
- Hibiscus is fourth #thisone
- Hibiscus is fifth
- Gardenias is fourth
- Gardenias is sixth
#v(1fr)
#problem()
Katydid cannot be in which position?
- Third #thisone
- Fourth
- Fifth
- Sixth
- Seventh
#v(1fr)
#problem()
If Gardenias is fourth, what must be true?
- Fence is first #thisone
- Hibiscus is third
- Irises is seventh
- Magnolia is first
- Magnolia is second
#v(1fr)
#problem()
Which one of the following,
if substituted for the second condition,
would have the same effect in determining the
arrangement of the photographs?
- If Fence is seventh, Hibiscus is second
- Gardenias is somewhere after Hibiscus, and either Fence or Magnolia is first
- Hibiscus must be somewhere between the first and sixth photographs
- Unless Hibiscus is second, it must be somewhere between Magnolia and Gardenias \
#if_solutions(text(fill: ored, [#sym.arrow.t.double `this one`]))
- Katydid is somewhere after Hibiscus, which must be after Fence.
#v(1fr)

54
src/Warm-Ups/Mario Kart/main.tex Executable file
View File

@ -0,0 +1,54 @@
\documentclass[
solutions,
hidewarning,
singlenumbering,
nopagenumber
]{../../../lib/tex/ormc_handout}
\usepackage{../../../lib/tex/macros}
\title{Warm-Up: Mario Kart}
\uptitler{\smallurl{}}
\subtitle{Prepared by Mark on \today}
\begin{document}
\maketitle
\problem{}
A standard Mario Kart cup consists of 12 players and four races. \par
Each race is scored as follows:
\begin{itemize}
\item 15 points are awarded for first place;
\item 12 for second;
\item and $(13 - \text{place})$ otherwise.
\end{itemize}
In any one race, no players may tie.
A player's score at the end of a cup is the sum of their scores for each of the four races.
\vspace{2mm}
An $n$-way tie occurs when the top $n$ players have the same score at the end of a round. \par
What is the largest possible $n$, and how is it achieved?
\begin{solution}
A 12-way tie is impossible, since the total number of point is not divisible by 12.
\vspace{2mm}
A 11-way tie is possible, with a top score of 28:
\begin{itemize}
\item Four players finish $1^\text{st}$, $3^\text{ed}$, $11^\text{th}$, and $12^\text{th}$;
% spell:off
\item Four players finish $2^\text{nd}$, $4^\text{th}$, $9^\text{th}$, and $10^\text{th}$;
% spell:on
\item Two players finish fifth twice and seventh twice,
\item One player finishes sixth in each race.
\end{itemize}
The final player always finishes eighth, with a non-tie score of 20.
\end{solution}
\end{document}

35
src/Warm-Ups/Mario Kart/main.typ
View File

@ -1,35 +0,0 @@
#import "@local/handout:0.1.0": *
#show: handout.with(
title: [Warm-Up: Mario Kart],
by: "Mark",
)
#problem()
A standard Mario Kart cup consists of 12 players and four races. \
Each race is scored as follows:
- 15 points are awarded for first place;
- 12 for second;
- and $(13 - #text("place"))$ otherwise.
In any one race, no players may tie. \
A player's score at the end of a cup is the sum of their scores for each of the four races.
#v(2mm)
An $n$-way tie occurs when the top $n$ players have the same score at the end of a round. \
What is the largest possible $n$, and how is it achieved?
#solution([
A 12-way tie is impossible, since the total number of point is not divisible by 12.
#v(2mm)
A 11-way tie is possible, with a top score of 28:
- Four players finish $1^#text("st")$, $3^#text("ed")$, $11^#text("th")$, and $12^#text("th")$;
- Four players finish $2^#text("nd")$, $4^#text("th")$, $9^#text("th")$, and $10^#text("th")$; // spell:disable-line
- Two players finish fifth twice and seventh twice,
- One player finishes sixth in each race.
The final player always finishes eighth, with a non-tie score of 20.
])

132
src/Warm-Ups/Odd Dice/main.tex Executable file
View File

@ -0,0 +1,132 @@
\documentclass[
nosolutions,
hidewarning,
singlenumbering,
nopagenumber
]{../../../lib/tex/ormc_handout}
\usepackage{../../../lib/tex/macros}
\usepackage{tikz}
\usetikzlibrary{arrows.meta}
\usetikzlibrary{shapes.geometric}
% We put nodes in a separate layer, so we can
% slightly overlap with paths for a perfect fit
\pgfdeclarelayer{nodes}
\pgfdeclarelayer{path}
\pgfsetlayers{main,nodes}
% Layer settings
\tikzset{
% Layer hack, lets us write
% later = * in scopes.
layer/.style = {
execute at begin scope={\pgfonlayer{#1}},
execute at end scope={\endpgfonlayer}
},
%
% Arrowhead tweak
>={Latex[ width=2mm, length=2mm ]},
%
% Nodes
main/.style = {
draw,
circle,
fill = white,
line width = 0.35mm
}
}
\title{Warm Up: Odd Dice}
\uptitler{\smallurl{}}
\subtitle{Prepared by Mark on \today}
\begin{document}
\maketitle
\problem{}
We say a set of dice $\{A, B, C\}$ is \textit{nontransitive}
if, on average, $A$ beats $B$, $B$ beats $C$, and $C$ beats $A$.
In other words, we get a counterintuitive \say{rock - paper - scissors} effect.
\vspace{2mm}
Create a set of nontransitive six-sided dice. \par
\hint{All sides should be numbered with positive integers less than 10.}
\begin{solution}
One possible set can be numbered as follows:
\begin{itemize}
\item Die $A$: $2, 2, 4, 4, 9, 9$
\item Die $B$: $1, 1, 6, 6, 8, 8$
\item Die $C$: $3, 3, 5, 5, 7, 7$
\end{itemize}
\vspace{4mm}
Another solution is below:
\begin{itemize}
\item Die $A$: $3, 3, 3, 3, 3, 6$
\item Die $B$: $2, 2, 2, 5, 5, 5$
\item Die $C$: $1, 4, 4, 4, 4, 4$
\end{itemize}
\end{solution}
\vfill
\problem{}
Now, consider the set of six-sided dice below:
\begin{itemize}
\item Die $A$: $4, 4, 4, 4, 4, 9$
\item Die $B$: $3, 3, 3, 3, 8, 8$
\item Die $C$: $2, 2, 2, 7, 7, 7$
\item Die $D$: $1, 1, 6, 6, 6, 6$
\item Die $E$: $0, 5, 5, 5, 5, 5$
\end{itemize}
On average, which die beats each of the others? Draw a graph. \par
\begin{solution}
\begin{center}
\begin{tikzpicture}[scale = 0.5]
\begin{scope}[layer = nodes]
\node[main] (a) at (-2, 0.2) {$a$};
\node[main] (b) at (0, 2) {$b$};
\node[main] (c) at (2, 0.2) {$c$};
\node[main] (d) at (1, -2) {$d$};
\node[main] (e) at (-1, -2) {$e$};
\end{scope}
\draw[->]
(a) edge (b)
(b) edge (c)
(c) edge (d)
(d) edge (e)
(e) edge (a)
(a) edge (c)
(b) edge (d)
(c) edge (e)
(d) edge (a)
(e) edge (b)
;
\end{tikzpicture}
\end{center}
\end{solution}
\vfill
Now, say we roll each die twice. What happens to the graph above?
\begin{solution}
The direction of each edge is reversed!
\end{solution}
\vfill
\pagebreak
\end{document}

111
src/Warm-Ups/Odd Dice/main.typ
View File

@ -1,111 +0,0 @@
#import "@local/handout:0.1.0": *
#import "@preview/cetz:0.3.1"
#show: handout.with(
title: [Warm-Up: Odd Dice],
by: "Mark",
)
#problem()
We say a set of dice ${A, B, C}$ is _nontransitive_
if, on average, $A$ beats $B$, $B$ beats $C$, and $C$ beats $A$.
In other words, we get a counterintuitive "rock - paper - scissors" effect.
#v(2mm)
Create a set of nontransitive six-sided dice. \
#hint([All sides should be numbered with positive integers less than 10.])
#solution([
One possible set can be numbered as follows:
- Die $A$: $2, 2, 4, 4, 9, 9$
- Die $B$: $1, 1, 6, 6, 8, 8$
- Die $C$: $3, 3, 5, 5, 7, 7$
#v(2mm)
Another solution is below:
- Die $A$: $3, 3, 3, 3, 3, 6$
- Die $B$: $2, 2, 2, 5, 5, 5$
- Die $C$: $1, 4, 4, 4, 4, 4$
])
#v(1fr)
#problem()
Now, consider the set of six-sided dice below:
- Die $A$: $4, 4, 4, 4, 4, 9$
- Die $B$: $3, 3, 3, 3, 8, 8$
- Die $C$: $2, 2, 2, 7, 7, 7$
- Die $D$: $1, 1, 6, 6, 6, 6$
- Die $E$: $0, 5, 5, 5, 5, 5$
On average, which die beats each of the others? Draw a diagram.
#solution(
align(
center,
cetz.canvas({
import cetz.draw: *
let s = 0.8 // Scale
let t = 13pt * s // text size
let radius = 0.3 * s
// Points
let a = (-2 * s, 0.2 * s)
let b = (0 * s, 2 * s)
let c = (2 * s, 0.2 * s)
let d = (1.2 * s, -2.1 * s)
let e = (-1.2 * s, -2.1 * s)
set-style(
stroke: (thickness: 0.6mm * s),
mark: (
end: (
symbol: ">",
fill: black,
offset: radius + (0.025 * s),
width: 1.2mm * s,
length: 1.2mm * s,
),
),
)
line(a, b)
line(b, c)
line(c, d)
line(d, e)
line(e, a)
line(a, c)
line(b, d)
line(c, e)
line(d, a)
line(e, b)
circle(a, radius: radius, fill: oblue, stroke: none)
circle(b, radius: radius, fill: oblue, stroke: none)
circle(c, radius: radius, fill: oblue, stroke: none)
circle(d, radius: radius, fill: oblue, stroke: none)
circle(e, radius: radius, fill: oblue, stroke: none)
content(a, text(fill: white, size: t, [*A*]))
content(b, text(fill: white, size: t, [*B*]))
content(c, text(fill: white, size: t, [*C*]))
content(d, text(fill: white, size: t, [*D*]))
content(e, text(fill: white, size: t, [*E*]))
}),
),
)
#v(1fr)
#problem()
Now, say we roll each die twice. What happens to the graph from the previous problem?
#solution([
The direction of each edge is reversed!
])
#v(1fr)

80
src/Warm-Ups/Painting/main.tex Executable file
View File

@ -0,0 +1,80 @@
\documentclass[
solutions,
singlenumbering,
nopagenumber
]{../../../lib/tex/ormc_handout}
\usepackage{../../../lib/tex/macros}
\title{Warm-Up: The Painting}
\uptitler{\smallurl{}}
\subtitle{Prepared by Mark on \today.}
\begin{document}
\maketitle
\problem{}
You have a painting on a string. \par
Hang the painting on two nails so that if either is removed, the painting falls. \par
\vspace{2mm}
You may detach the string as you hang the painting, but it must be re-attached once you're done.
\note{The solution to this problem isn't a \say{think outside the box} trick, it's a clever wrapping of the string.}
\begin{center}
\begin{tikzpicture}[scale=2.0]
\draw[line width = 0.5mm]
(0, 1) --
(2, 1) --
(2, 0) --
(0, 0) --
cycle
;
\draw[line width = 0.5mm, dotted]
(0.1, 1) --
(1, 1.5) --
(1.9, 1)
;
\fill (1, 1.5) circle[radius = 0.25mm];
\draw[line width = 0.2mm]
(0.66, 0.66) --
(0.66, 0.35) --
(0.60, 0.1)
(0.72, 0.1)--(0.66, 0.35)
;
\draw[line width = 0.2mm]
(0.66, 0.575) --
(0.6, 0.475) --
(0.525, 0.575)
(0.66, 0.575) --
(0.72, 0.475) --
(0.795, 0.575)
;
\fill[color=white] (0.66, 0.66) circle[radius = 0.8mm];
\draw (0.66, 0.66) circle[radius = 0.8mm];
\end{tikzpicture}
\end{center}
\begin{solution}
Say we have a left nail and a right nail. The path of the string is as follows:
\begin{itemize}
\item Start on the left
\item Move over both nails, wrap right nail cw
\item Wrap left nail ccw
\item Wrap right nail ccw
\item Exit downwards, in between both nails
\end{itemize}
\end{solution}
\end{document}

82
src/Warm-Ups/Painting/main.typ
View File

@ -1,82 +0,0 @@
#import "@local/handout:0.1.0": *
#import "@preview/cetz:0.3.1"
#show: handout.with(
title: [Warm-Up: What's an AST?],
by: "Mark",
subtitle: "Based on a true story.",
)
#problem()
Say we have a painting on a string. \
Hang the painting on two nails so that if either is removed, the painting falls. \
#v(2mm)
You may detach the string as you hang the painting, but it must be re-attached once you're done. \
#hint[The solution to this problem isn't a "think outside the box" trick, it's a clever wrapping of the string.]
#v(2mm)
#align(
center,
cetz.canvas({
import cetz.draw: *
let s = 2.5
line(
(0 * s, 1 * s),
(2 * s, 1 * s),
(2 * s, 0 * s),
(0 * s, 0 * s),
close: true,
stroke: (thickness: 0.8mm),
)
line(
(0.1 * s, 1 * s),
(0.5 * s, 1.5 * s),
(1.5 * s, 1.5 * s),
(1.9 * s, 1 * s),
stroke: (thickness: 0.5mm, dash: "dotted"),
)
circle((0.5 * s, 1.5 * s), radius: 0.04 * s, fill: black, stroke: none)
circle((1.5 * s, 1.5 * s), radius: 0.04 * s, fill: black, stroke: none)
line(
(0.66 * s, 0.66 * s),
(0.66 * s, 0.35 * s),
(0.60 * s, 0.1 * s),
)
line(
(0.72 * s, 0.1 * s),
(0.66 * s, 0.35 * s),
)
line(
(0.66 * s, 0.575 * s),
(0.6 * s, 0.475 * s),
(0.525 * s, 0.575 * s),
)
line(
(0.66 * s, 0.575 * s),
(0.72 * s, 0.475 * s),
(0.795 * s, 0.575 * s),
)
circle((0.66 * s, 0.66 * s), radius: 0.07 * s, fill: white)
}),
)
#solution([
Say we have a left nail and a right nail. The path of the string is as follows:
- Start on the left
- Move over both nails, wrap right nail cw
- Wrap left nail ccw
- Wrap right nail ccw
- Exit downwards, in between both nails
])

57
src/Warm-Ups/Partition Products/main.tex Executable file
View File

@ -0,0 +1,57 @@
\documentclass[
solutions,
singlenumbering,
nopagenumber
]{../../../lib/tex/ormc_handout}
\usepackage{../../../lib/tex/macros}
\title{Warm-Up: Partition Products}
\uptitler{\smallurl{}}
\subtitle{Prepared by Mark on \today.}
\begin{document}
\maketitle
\problem{}
Take any positive integer $n$. \par
Now, write it as sum of smaller positive integers: $n = a_1 + a_2 + ... + a_k$ \par
Maximize the product $a_1 \times a_2 \times ... \times a_k$
\begin{solution}
\textbf{Interesting Solution:}
Of course, all $a_i$ should be greater than $1$. \par
Also, all $a_i$ should be smaller than four, since $x \leq x(x-2)$ if $x \geq 4$. \par
Thus, we're left with sequences that only contain 2 and 3. \par
\note{Note that two twos are the same as one four, but we exclude fours for simplicity.}
\vspace{2mm}
Finally, we see that $3^2 > 2^3$, so any three twos are better repackaged as two threes. \par
The best sequence $a_i$ thus consists of a maximal number of threes followed by 0, 1, or 2 twos.
\linehack{}
\textbf{Calculus Solution:}
First, solve this problem for equal, non-integer $a_i$:
\vspace{2mm}
We know $n = \prod{a_i}$, thus $\ln(n) = \sum{\ln(a_i)}$. \par
If all $a_i$ are equal, we get $\ln(n) = k \times \ln(n / k)$. \par
Derive wrt $k$ and set to zero to get $\ln(n / k) = 1$ \par
So $k = n / e$ and $n / k = e \approx 2.7$
\vspace{2mm}
If we try to approximate this with integers, we get the same solution as above.
\end{solution}
\end{document}

41
src/Warm-Ups/Partition Products/main.typ
View File

@ -1,41 +0,0 @@
#import "@local/handout:0.1.0": *
#show: handout.with(
title: [Warm-Up: Partition Products],
by: "Mark",
)
#problem()
Take any positive integer $n$. \
Now, write it as sum of smaller positive integers: $n = a_1 + a_2 + ... a_k$ \
Maximize the product $a_1 #sym.times a_2 #sym.times ... #sym.times a_k$
#solution([
*Interesting Solution:*
Of course, all $a_i$ should be greater than $1$. \
Also, all $a_i$ should be smaller than four, since $x <= x(x-2)$ if $x >= 4$. \
Thus, we're left with sequences that only contain 2 and 3. \
#note([Note that two twos are the same as one four, but we exclude fours for simplicity.])
#v(2mm)
Finally, we see that $3^2 > 2^3$, so any three twos are better repackaged as two threes. \
The best sequence $a_i$ thus consists of a maximal number of threes followed by 0, 1, or 2 twos.
#v(8mm)
*Calculus Solution:*
First, solve this problem for equal, real $a_i$:
#v(2mm)
We know $n = product(a_i)$, thus $ln(n) = sum(ln(a_i))$. \
If all $a_i$ are equal, we get $ln(n) = k #sym.times ln(n / k)$. \
Derive wrt $k$ and set to zero to get $ln(n / k) = 1$ \
So $k = n / e$ and $n / k = e #sym.approx 2.7$
#v(2mm)
If we try to approximate this with integers, we get the same solution as above.
])

47
src/Warm-Ups/Passing Balls/main.tex Executable file
View File

@ -0,0 +1,47 @@
\documentclass[
solutions,
singlenumbering,
nopagenumber
]{../../../lib/tex/ormc_handout}
\usepackage{../../../lib/tex/macros}
\usepackage{graphicx}
\title{Warm-Up: Passing Balls}
\uptitler{\smallurl{}}
\subtitle{Prepared by Mark on \today}
\begin{document}
\maketitle
\problem{}
Twelve people are standing in a circle. Each is assigned a number between 1 and 12. \par
Participants numbered 1, 2, 3, and 4 hold red, green, yellow, and black balls, respectively. \par
Everyone else is empty-handed.
\vspace{2mm}
Each participant can pass their ball to any student that is exactly 5 positions away. \par
Balls cannot be passed to someone who has one in hand.
\vspace{2mm}
After a number of passes, the first four participants again hold all the balls. \par
Participant 1 has a black ball. Which balls are held by participants 2, 3, and 4?
\begin{solution}
\begin{itemize}
\item the graph of possible moves is isomorphic to a circle (since 5 and 12 are coprime),
\item but the balls get passed around, so swapping the place of any two balls is not allowed. \\
Therefore, the balls will stay in their initial (cyclic) order:
\end{itemize}
\begin{center}
\includegraphics[width=\textwidth]{pass-sol.png}
\end{center}
\end{solution}
\end{document}

192
src/Warm-Ups/Passing Balls/main.typ
View File

@ -1,192 +0,0 @@
#import "@local/handout:0.1.0": *
#import "@preview/cetz:0.3.1"
#show: handout.with(
title: [Warm-Up: Passing Balls],
by: "Mark",
)
#problem()
Twelve people are standing in a circle. Each is assigned a number between 1 and 12. \
Participants numbered 1, 2, 3, and 4 hold red, green, yellow, and black balls, respectively. \
Everyone else is empty-handed.
#v(2mm)
Each participant can pass their ball to any student that is exactly 5 positions away. \
Balls cannot be passed to someone who has one in hand.
#v(2mm)
After a number of passes, the first four participants again hold all the balls. \
Participant 1 has a black ball. Which balls are held by participants 2, 3, and 4?
#solution([
The graph of possible moves is isomorphic to a circle (since 5 and 12 are coprime), \
so the order of the balls cannot be changed as they are passed around.
#v(2mm)
Therefore, the balls will stay in their initial (cyclic) order:
#v(2mm)
#{
let s = 0.7 // scale
let t = 12pt * s // text size
let radius = 0.35
let pts = (
(0 * s, 3 * s),
(1 * s, 2 * s),
(2 * s, 1 * s),
(3 * s, 0 * s),
(2 * s, -1 * s),
(1 * s, -2 * s),
(0 * s, -3 * s),
(-1 * s, -2 * s),
(-2 * s, -1 * s),
(-3 * s, 0 * s),
(-2 * s, 1 * s),
(-1 * s, 2 * s),
)
let pts_shuf = (
(0 * s, 3 * s), // 1
(1 * s, -2 * s), // 6
(-2 * s, 1 * s), // 11
(3 * s, 0 * s), // 4
(-2 * s, -1 * s), // 9
(1 * s, 2 * s), // 2
(0 * s, -3 * s), // 7
(-1 * s, 2 * s), // 12
(2 * s, -1 * s), // 5
(-3 * s, 0 * s), // 10
(2 * s, 1 * s), // 3
(-1 * s, -2 * s), // 8
)
table(
stroke: none,
align: center,
columns: (1fr, 1fr, 1fr),
cetz.canvas({
import cetz.draw: *
set-style(stroke: (thickness: 0.4mm, paint: black))
line(..pts_shuf, close: true)
let i = 1
for p in pts {
circle(
p,
radius: radius * s,
fill: if i == 1 {
ored
} else if i == 2 {
ogreen
} else if i == 3 {
oorange
} else if i == 4 {
oblue
} else { white },
)
content(
p,
text(
fill: if i <= 4 {
white
} else {
black
},
size: t,
[*#i*],
),
)
i = i + 1
}
}),
cetz.canvas({
import cetz.draw: *
set-style(stroke: (thickness: 0.4mm, paint: black))
line(..pts, close: true)
let i = 1
for p in pts {
let l = calc.rem(((i - 1) * 5), 12) + 1
circle(
p,
radius: radius * s,
fill: if l == 1 {
ored
} else if l == 2 {
ogreen
} else if l == 3 {
oorange
} else if l == 4 {
oblue
} else { white },
)
content(
p,
text(
fill: if l <= 4 {
white
} else {
black
},
size: t,
[*#l*],
),
)
i = i + 1
}
}),
cetz.canvas({
import cetz.draw: *
set-style(stroke: (thickness: 0.4mm, paint: black))
line(..pts, close: true)
let i = 1
for p in pts {
let l = calc.rem(((i - 1) * 5), 12) + 1
circle(
p,
radius: radius * s,
fill: if l == 1 {
oblue
} else if l == 2 {
oorange
} else if l == 3 {
ored
} else if l == 4 {
ogreen
} else { white },
)
content(
p,
text(
fill: if l <= 4 {
white
} else {
black
},
size: t,
[*#l*],
),
)
i = i + 1
}
}),
)
}
])

BIN
src/Warm-Ups/Passing Balls/pass-sol.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 47 KiB

34
src/Warm-Ups/Prime Factors/main.tex Executable file
View File

@ -0,0 +1,34 @@
\documentclass[
solutions,
singlenumbering,
nopagenumber,
hidewarning
]{../../../lib/tex/ormc_handout}
\usepackage{../../../lib/tex/macros}
\title{Warm-Up: Prime Factors}
\uptitler{\smallurl{}}
\subtitle{Prepared by Mark on \today.}
\begin{document}
\maketitle
\problem{}
What proportion of integers have $2$ as their smallest prime factor?
% 1^2
\vfill
\problem{}
What proportion of integers have $3$ as their second-smallest prime factor?
% 1/6
\vfill
\problem{}
What is the median second-smallest prime factor?
% 37
\vfill
\end{document}

23
src/Warm-Ups/Prime Factors/main.typ
View File

@ -1,23 +0,0 @@
#import "@local/handout:0.1.0": *
#show: handout.with(
title: [Warm-Up: Prime Factors],
by: "Mark",
)
#problem()
What proportion of integers have $2$ as their smallest prime factor?
#solution([$1 div 2$])
#v(1fr)
#problem()
What proportion of integers have $3$ as their second-smallest prime factor?
#solution([$1 div 6$])
#v(1fr)
#problem()
What is the median second-smallest prime factor?
#solution([37])
#v(1fr)

153
src/Warm-Ups/Regex/main.tex Normal file
View File

@ -0,0 +1,153 @@
\documentclass[
solutions,
hidewarning,
]{../../../lib/tex/ormc_handout}
\usepackage{../../../lib/tex/macros}
\usepackage{xcolor}
\usepackage{soul}
\usepackage{hyperref}
\definecolor{Light}{gray}{.90}
\sethlcolor{Light}
\newcommand{\htexttt}[1]{\texttt{\hl{#1}}}
\title{The Regex Warm-Up}
\uptitler{\smallurl{}}
\subtitle{Prepared by Mark on \today}
\begin{document}
\maketitle
Last time, we discussed Deterministic Finite Automata. One interesting application of these mathematical objects is found in computer science: Regular Expressions. \par
This is often abbreviated \say{regex}, which is pronounced like \say{gif.}
\vspace{2mm}
Regex is a language used to specify patterns in a string. You can think of it as a concise way to define a DFA, using text instead of a huge graph. \par
Often enough, a clever regex pattern can do the work of a few hundred lines of code.
\vspace{2mm}
Like the DFAs we've studied, a regex pattern \textit{accepts} or \textit{rejects} a string. However, we don't usually use this terminology with regex, and instead say that a string \textit{matches} or \textit{doesn't match} a pattern.
\vspace{5mm}
Regex strings consist of characters, quantifiers, sets, and groups.
\vspace{5mm}
\textbf{Quantifiers} \par
Quantifiers specify how many of a character to match. \par
There are four of these: \htexttt{+}, \htexttt{*}, \htexttt{?}, and \htexttt{\{ \}}
\vspace{2mm}
\htexttt{+} means \say{match one or more of the preceding token} \par
\htexttt{*} means \say{match zero or more of the preceding token}
For example, the pattern \htexttt{ca+t} will match the following strings:
\begin{itemize}
\item \texttt{cat}
\item \texttt{caat}
\item \texttt{caaaaaaaat}
\end{itemize}
\htexttt{ca+t} will \textbf{not} match the string \texttt{ct}. \par
The pattern \htexttt{ca*t} will match all the strings above, including \texttt{ct}.
\vspace{2mm}
\htexttt{?} means \say{match one or none of the preceding token} \par
The pattern \htexttt{linea?r} will match only \texttt{linear} and \texttt{liner}.
\vspace{2mm}
Brackets \htexttt{\{min, max\}} are the most flexible quantifier. \par
They specify exactly how many tokens to match: \par
\htexttt{ab\{2\}a} will match only \texttt{abba}. \par
\htexttt{ab\{1,3\}a} will match only \texttt{aba}, \texttt{abba}, and \texttt{abbba}. \par
% spell:off
\htexttt{ab\{2,\}a} will match any \texttt{ab...ba} with at least two \texttt{b}s.
% spell:on
\vspace{5mm}
\problem{}
Write the patterns \htexttt{a*} and \htexttt{a+} using only \htexttt{\{ \}}.
\vfill
\problem{}
Draw a DFA equivalent to the regex pattern \htexttt{01*0}.
\vfill
\pagebreak
\textbf{Characters, Sets, and Groups} \par
In the previous section, we saw how we can specify characters literally: \par
\texttt{a+} means \say{one or more \texttt{a} character}
\vspace{2mm}
There are, of course, other ways we can specify characters.
\vspace{2mm}
The first such way is the \textit{set}, denoted \htexttt{[ ]}. A set can pretend to be any character inside it. \par
For example, \htexttt{m[aoy]th} will match \texttt{math}, \texttt{moth}, or \texttt{myth}. \par
\htexttt{a[01]+b} will match \texttt{a0b}, \texttt{a111b}, \texttt{a1100110b}, and any other similar string. \par
You may negate a set with a \htexttt{\textasciicircum}. \par
\htexttt{[\textasciicircum abc]} will match any character except \texttt{a}, \texttt{b}, or \texttt{c}, including symbols and spaces.
\vspace{2mm}
If we want to keep characters together, we can use the \textit{group}, denoted \htexttt{( )}. \par
Groups work exactly as you'd expect, representing an atomic\footnotemark{} group of characters. \par
\htexttt{a(01)+b} will match \texttt{a01b} and \texttt{a010101b}, but will \textbf{not} match \texttt{a0b}, \texttt{a1b}, or \texttt{a1100110b}.
\footnotetext{In other words, \say{unbreakable}}
\problem{}<regex>
You are now familiar with most of the tools regex has to offer. \par
Write patterns that match the following strings:
\begin{enumerate}[itemsep=1mm]
\item An ISO-8601 date, like \texttt{2022-10-29}. \par
\hint{Invalid dates like \texttt{2022-13-29} should also be matched.}
\item An email address. \par
\hint{Don't forget about subdomains, like \texttt{math.ucla.edu}.}
\item A UCLA room number, like \texttt{MS 5118} or \texttt{Kinsey 1220B}.
\item Any ISBN-10 of the form \texttt{0-316-00395-7}. \par
\hint{Remember that the check digit may be an \texttt{X}. Dashes are optional.}
\item A word of even length. \par
\hint{The set \texttt{[A-z]} contains every english letter, capitalized and lowercase. \\
\texttt{[a-z]} will only match lowercase letters.}
\item A word with exactly 3 vowels. \par
\hint{The special token \texttt{\textbackslash w} will match any word character. It is equivalent to \texttt{[A-z0-9\_]} \\ \texttt{\_} stands for a literal underscore.}
\item A word that has even length and exactly 3 vowels.
\item A sentence that does not start with a capital letter.
\end{enumerate}
\vfill
\problem{}
If you'd like to know more, check out \url{https://regexr.com}. It offers an interactive regex prompt, as well as a cheatsheet that explains every other regex token there is. \par
You will find a nice set of challenges at \url{https://alf.nu/RegexGolf}.
I especially encourage you to look into this if you are interested in computer science.
\end{document}

135
src/Warm-Ups/Regex/main.typ
View File

@ -1,135 +0,0 @@
#import "@local/handout:0.1.0": *
#show: handout.with(
title: [The Regex Warm-Up],
by: "Mark",
)
Last time, we discussed Deterministic Finite Automata. One interesting application of these mathematical objects is found in computer science: Regular Expressions. \
This is often abbreviated "regex," which is pronounced like "gif."
#v(2mm)
Regex is a language used to specify patterns in a string. You can think of it as a concise way to define a DFA, using text instead of a huge graph. \
Often enough, a clever regex pattern can do the work of a few hundred lines of code.
#v(2mm)
Like the DFAs we've studied, a regex pattern _accepts_ or _rejects_ a string. However, we don't usually use this terminology with regex, and instead say that a string _matches_ or _doesn't match_ a pattern.
#v(5mm)
Regex strings consist of characters, quantifiers, sets, and groups.
#v(5mm)
*Quantifiers* \
Quantifiers specify how many of a character to match. \
There are four of these: `+`, `*`, `?`, and `{ }`.
#v(4mm)
`+` means "match one or more of the preceding token" \
`*` means "match zero or more of the preceding token"
For example, the pattern `ca+t` will match the following strings:
- `cat`
- `caat`
- `caaaaaaaat`
`ca+t` will *not* match the string `ct`. \
The pattern `ca*t` will match all the strings above, including `ct`.
#v(4mm)
`?` means "match one or none of the preceding token" \
The pattern `linea?r` will match only `linear` and `liner`.
#v(4mm)
Brackets `{min, max}` are the most flexible quantifier. \
They specify exactly how many tokens to match: \
`ab{2}a` will match only `abba`. \
`ab{1,3}a` will match only `aba`, `abba`, and `abbba`. \
`ab{2,}a` will match any `ab...ba` with at least two `b`s. // spell:disable-line
#problem()
Write the patterns `a*` and `a+` using only `{ }`.
#v(1fr)
#problem()
Draw a DFA equivalent to the regex pattern `01*0`.
#v(1fr)
#pagebreak()
*Characters, Sets, and Groups* \
In the previous section, we saw how we can specify characters literally: \
`a+` means "one or more `a` characters" \
There are, of course, other ways we can specify characters.
#v(4mm)
The first such way is the _set_, denoted `[ ]`. A set can pretend to be any character inside it. \
For example, `m[aoy]th` will match `math`, `moth`, or `myth`. \
`a[01]+b` will match `a0b`, `a111b`, `a1100110b`, and any other similar string. \
#v(4mm)
We can negate a set with a `^`. \
`[^abc]` will match any single character except `a`, `b`, or `c`, including symbols and spaces.
#v(4mm)
If we want to keep characters together, we can use the _group_, denoted `( )`. \
Groups work exactly as you'd expect, representing an atomic#footnote([In other words, "unbreakable"]) group of characters. \
`a(01)+b` will match `a01b` and `a010101b`, but will *not* match `a0b`, `a1b`, or `a1100110b`.
#problem()
You are now familiar with most of the tools regex has to offer. \
Write patterns that match the following strings:
- An ISO-8601 date, like `2022-10-29`. \
#hint([Invalid dates like `2022-13-29` should also be matched.])
- An email address. \
#hint([Don't forget about subdomains, like `math.ucla.edu`.])
- A UCLA room number, like `MS 5118` or `Kinsey 1220B`.
- Any ISBN-10 of the form `0-316-00395-7`. \
#hint([Remember that the check digit may be an `X`. Dashes are optional.])
- A word of even length. \
#hint([
The set `[A-z]` contains every english letter, capitalized and lowercase. \
`[a-z]` will only match lowercase letters.
])
- A word with exactly 3 vowels. \
#hint([
The special token `\w` will match any word character. \
It is equivalent to `[A-z0-9_]`. `_` represents a literal underscore.
])
- A word that has even length and exactly 3 vowels.
- A sentence that does not start with a capital letter.
#v(1fr)
#problem()
If you'd like to know more, check out `https://regexr.com`.
It offers an interactive regex prompt,
as well as a cheatsheet that explains every other regex token there is. \
You can find a nice set of challenges at `https://alf.nu/RegexGolf`.

75
src/Warm-Ups/Somewhat Random Numbers/main.typ
View File

@ -1,75 +0,0 @@
#import "@local/handout:0.1.0": *
#show: handout.with(
title: [Somewhat Random Numbers],
by: "Mark",
)
#problem()
Alice generates 100 random numbers uniformly from $[0,1]$. \
Bob generates 101 random numbers from $[0, 1]$, but deletes the lowest result.
#v(2mm)
Say we have both of the resulting arrays, but do not know who generated each one. \
We would like to guess which of the two was generated by Bob. \
What is the optimal strategy, and what is its probability of guessing correctly?
#solution([
Looking at the mean seems like a good idea, but there's a better way: \
Assign the array with the smaller _minimum_ to Alice.
#v(3mm)
To compute the probability, generate 201 numbers. \
Assign the first 100 to Alice and the rest to Bob. \
Look at the lowest two numbers (of these 201, *before* Bob drops his lowest).
#v(8mm)
We'll use the following notation: \
`AB` means the lowest was owned by Alice, and the second-lowest, by Bob.
#v(2mm)
Probabilities are as follows: \
- `AA`: $100\/201 times 99\/200 approx 0.246$
- `AB`: $100\/201 times 101\/200 approx 0.251$
- `BA`: $101\/201 times 100\/200 approx 0.251$ // spell:disable-line
- `BB`: $101\/201 times 100\/200 approx 0.251$
#v(4mm)
Now, Bob drops his lowest number. \
We'll cross out the number he drops and box the new lowest number (i.e, the one we observe):
- #{
(
box(`A`, stroke: ored, inset: 1pt)
+ box(`A`, inset: 1pt)
+ box([: $approx 0.246$], inset: (top: 1pt, bottom: 1pt))
)
}
- #{
(
box(`A`, stroke: ored, inset: 1pt)
+ box(strike(`B`), inset: 1pt)
+ box([: $approx 0.251$], inset: (top: 1pt, bottom: 1pt))
)
}
- #{
(
box(strike(`B`), inset: 1pt)
+ box(`A`, stroke: ored, inset: 1pt)
+ box([: $approx 0.251$], inset: (top: 1pt, bottom: 1pt))
)
}
- #{
(
box(strike(`B`), inset: 1pt)
+ box(`B`, stroke: ored, inset: 1pt)
+ box([: $approx 0.251$], inset: (top: 1pt, bottom: 1pt))
)
}
#v(8mm)
Alice has the smallest number in 3 of 4 cases, which have a total probability of $approx 0.749$.
])

6
src/Warm-Ups/Somewhat Random Numbers/meta.toml
View File

@ -1,6 +0,0 @@
[metadata]
title = "Somewhat Random Numbers"
[publish]
handout = true
solutions = true

89
src/Warm-Ups/Sysadmin/main.tex Executable file
View File

@ -0,0 +1,89 @@
\documentclass[
solutions,
hidewarning,
singlenumbering,
nopagenumber
]{../../../lib/tex/ormc_handout}
\usepackage{../../../lib/tex/macros}
\usepackage{tikz}
\title{The Sysadmin's Warm-Up}
\uptitler{\smallurl{}}
\subtitle{Prepared by Mark on \today}
\begin{document}
\maketitle
Most of you have seen a hard drive. Many have touched one, and a lucky few have poked around inside one. These devices have two interesting properties:
\begin{enumerate}
\item They hold valuable data
\item They eventually fail
\end{enumerate}
Needless to say, this is a problem. \par
We need to design a system that allows hard drives to fail without data loss.
\definition{}
You can think of a hard drive as a long string of bits. \par
Assume all hard drives can store 1 TiB of data.
\begin{center}
\begin{tikzpicture}
\node[above] at (1/2, 0) {Drive A};
\draw (0cm, 0cm) -- (0cm, -3cm);
\draw (1cm, 0cm) -- (1cm, -3cm);
\foreach \i in {0,...,-6} {
\draw (0cm,\i cm / 2) -- (1cm ,\i cm / 2);
}
\node at (1/2, - 1 / 4) {1};
\node at (1/2, - 3 / 4) {1};
\node at (1/2, - 5 / 4) {0};
\node at (1/2, - 7 / 4) {...};
\node at (1/2, - 9 / 4) {1};
\node at (1/2, -11 / 4) {0};
\node[above] at (5/2, 0) {Drive B};
\draw (2cm, 0cm) -- (2cm, -3cm);
\draw (3cm, 0cm) -- (3cm, -3cm);
\foreach \i in {0,...,-6} {
\draw (2cm,\i cm / 2) -- (3cm ,\i cm / 2);
}
\node at (5/2, - 1 / 4) {0};
\node at (5/2, - 3 / 4) {1};
\node at (5/2, - 5 / 4) {0};
\node at (5/2, - 7 / 4) {...};
\node at (5/2, - 9 / 4) {0};
\node at (5/2, -11 / 4) {1};
\end{tikzpicture}
\end{center}
\problem{}
Suppose we have two hard drives. How can we arrange our data so that...
\begin{enumerate}
\item We get 1 TiB of usable storage
\item We lose no data if any one drive fails
\end{enumerate}
\vfill
\problem{}
Suppose we have three hard drives. How can we arrange our data so that...
\begin{enumerate}
\item We get 2 TiB of usable storage
\item We lose no data if any one drive fails
\end{enumerate}
\vfill
\end{document}

35
src/Warm-Ups/Sysadmin/main.typ
View File

@ -1,35 +0,0 @@
#import "@local/handout:0.1.0": *
#show: handout.with(
title: [The Sysadmin's Warm-Up],
by: "Mark",
)
Most of you have seen a hard drive. \
Many have touched one, and a lucky few have taken one apart. \
These devices have two interesting properties:
- They hold valuable data
- They inevitably fail
Needless to say, this is a problem. \
We would like to design a system that tolerates hard drive failures without data loss.
#definition()
You can think of a hard drive as a long string of bits. \
Assume all hard drives in the following problems have the same size. \
If a hard drive "fails", all data on it is instantly lost.
#problem()
Suppose we have two hard drives. How can we arrange our data so that...
- We get 1 TiB of usable storage
- We lose no data if any one drive fails
#v(1fr)
#problem()
Suppose we have three hard drives. How can we arrange our data so that...
- We get 2 TiB of usable storage
- We lose no data if any one drive fails
#v(1fr)

30
src/Warm-Ups/Travellers/main.tex Executable file
View File

@ -0,0 +1,30 @@
\documentclass[
solutions,
singlenumbering,
nopagenumber
]{../../../lib/tex/ormc_handout}
\usepackage{../../../lib/tex/macros}
\title{Warm-Up: Travellers}
\uptitler{\smallurl{}}
\subtitle{Prepared by Mark on \today}
\begin{document}
\maketitle
\problem{}
Four travellers are on a plane, each moving along a straight line at an arbitrary constant speed. \par
No two of their paths are parallel, and no three intersect at the same point. \par
We know that traveller A has met travelers B, C, and D, \par
and that traveller B has met C and D (and A). Show that C and D must also have met. \par
\begin{solution}
When a body travels at a constant speed, its graph with respect to time is a straight line. \par
So, we add time axis in the third dimension, perpendicular to our plane. \par
Naturally, the projection of each of these onto the plane corresponds to a road.
Now, note that two intersecting lines define a plane and use the conditions in the problem to show that no two lines are parallel.
\end{solution}
\end{document}

20
src/Warm-Ups/Travellers/main.typ
View File

@ -1,20 +0,0 @@
#import "@local/handout:0.1.0": *
#show: handout.with(
title: [Warm-Up: Travellers],
by: "Mark",
)
#problem()
Four travellers are on a plane, each moving along a straight line at an arbitrary constant speed. \
No two of their paths are parallel, and no three intersect at the same point. \
We know that traveller A has met travelers B, C, and D, \
and that traveller B has met C and D (and A). Show that C and D must also have met.
#solution([
When a body travels at a constant speed, its graph with respect to time is a straight line. \
So, we add time axis in the third dimension, perpendicular to our plane. \
Naturally, the projection of each of these onto the plane corresponds to a road.
Now, note that two intersecting lines define a plane and use the conditions in the problem to show that no two lines are parallel.
])

26
src/Warm-Ups/Tuesday/main.typ
View File

@ -1,26 +0,0 @@
#import "@local/handout:0.1.0": *
#show: handout.with(
title: [Warm-Up: Tuesday],
by: "Mark",
)
#problem()
Charlie has two children. \
One of them is a boy born on a Tuesday. \
What is the probability that Charlie has two boys?
#solution([
$13 / 27$, which notably isn't $1/2$.
#v(2mm)
Draw a $14 times 14$ square, highlight the possible cases, and you'll see it. \
#v(2mm)
Order is very important in this problem. \
If we knew that the _first_ child was a boy born on Tuesday,
the probability of two boys would be $1/2$. \
Also consider a smaller case where a week has two days.
])

6
src/Warm-Ups/Tuesday/meta.toml
View File

@ -1,6 +0,0 @@
[metadata]
title = "Tuesday"
[publish]
handout = true
solutions = true

43
src/Warm-Ups/What's an AST/main.tex Executable file
View File

@ -0,0 +1,43 @@
\documentclass[
solutions,
hidewarning,
singlenumbering,
nopagenumber
]{../../../lib/tex/ormc_handout}
\usepackage{../../../lib/tex/macros}
\usepackage[linguistics]{forest}
\title{Warm-Up: What's an AST?}
\uptitler{\smallurl{}}
\subtitle{Prepared by Mark on \today. \\ Based on a true story.}
\begin{document}
\maketitle
Say you have a valid string of simple arithmetic that contains no unary operators (like $3!$ or $-4$) and no parenthesis:
$$
3 + 9 \times 8 \div 5 \land 6
$$
You may assume that all numbers and operators in this string consist of exactly one character. \\
Devise an algorithm that turns this string into a tree (as shown below), respecting the order of operations $[\land, \times, \div, +, -]$.
\begin{center}
\begin{forest}
[$+$
[3]
[$\div$
[$\times$[9][8]]
[$\land$[5][6]]
]
]
\end{forest}
\end{center}
\end{document}

74
src/Warm-Ups/What's an AST/main.typ
View File

@ -1,74 +0,0 @@
#import "@local/handout:0.1.0": *
#import "@preview/cetz:0.3.1"
#show: handout.with(
title: [Warm-Up: What's an AST?],
by: "Mark",
subtitle: "Based on a true story.",
)
#problem()
Say we have a valid string of simple arithmetic that contains \
no unary operators (like $3!$ or $-4$) and no parenthesis:
#v(2mm)
$
3 + 9 times 8 div 5 and 6
$
#v(2mm)
You may assume that all numbers and operators in this string consist of exactly one character. \
Devise an algorithm that turns such strings into a tree (as shown below), \
respecting the order of operations $[and, times, div, +, -]$.
#v(2mm)
#align(
center,
cetz.canvas({
import cetz.draw: *
// spell:off
content((0, 0), $+$, name: "r")
content((-0.5, -1), $3$, name: "a")
content((0.5, -1), $div$, name: "b")
content((-0.3, -2), $times$, name: "ba")
content((1.3, -2), $and$, name: "bb")
content((-0.8, -3), $9$, name: "baa")
content((0.2, -3), $8$, name: "bab")
content((0.8, -3), $5$, name: "bba")
content((1.8, -3), $6$, name: "bbb")
// spell:on
// Zero-sized arrows are a hack for offset.
set-style(
stroke: (thickness: 0.3mm),
mark: (
start: (
symbol: "|",
offset: 0.25,
width: 0mm,
length: 0mm,
),
end: (
symbol: "|",
offset: 0.25,
width: 0mm,
length: 0mm,
),
),
)
// spell:off
line("r", "a")
line("r", "b")
line("b", "ba")
line("b", "bb")
line("ba", "baa")
line("ba", "bab")
line("bb", "bba")
line("bb", "bbb")
// spell:on
}),
)

66
src/Warm-Ups/Wild Tic-Tac-Toe/main.tex Executable file
View File

@ -0,0 +1,66 @@
\documentclass[
solutions,
hidewarning,
singlenumbering,
nopagenumber
]{../../../lib/tex/ormc_handout}
\usepackage{../../../lib/tex/macros}
% x,y,scale,style
\def\ttt#1#2#3#4{
\draw[#4] (#1, #2+#3) -- (#1+#3+#3+#3, #2+#3);
\draw[#4] (#1, #2+#3+#3) -- (#1+#3+#3+#3, #2+#3+#3);
\draw[#4] (#1+#3, #2) -- (#1+#3, #2+#3+#3+#3);
\draw[#4] (#1+#3+#3, #2) -- (#1+#3+#3, #2+#3+#3+#3);
}
\title{Warm-Up: Wild Tic-Tac-Toe}
\uptitler{\smallurl{}}
\subtitle{Prepared by Mark on \today.}
\begin{document}
\maketitle
\problem{}
In wild tic-tac-toe, players may place either an X or O on each move. The player that first completes a
row of any three symbols wins. Show that the first player always has a winning strategy.
\vfill
\begin{center}
\begin{tikzpicture}[scale=0.60]
\ttt{0}{0}{2}{line width=0.3mm}
\ttt{7}{0}{2}{line width=0.3mm}
\ttt{14}{0}{2}{line width=0.3mm}
\ttt{0}{7}{2}{line width=0.3mm}
\ttt{7}{7}{2}{line width=0.3mm}
\ttt{14}{7}{2}{line width=0.3mm}
\end{tikzpicture}
\end{center}
\vfill
\problem{}
Now, say the first player to complete a row loses. Who has a winning strategy now?
\vfill
\begin{center}
\begin{tikzpicture}[scale=0.60]
\ttt{0}{0}{2}{line width=0.3mm}
\ttt{7}{0}{2}{line width=0.3mm}
\ttt{14}{0}{2}{line width=0.3mm}
\ttt{0}{7}{2}{line width=0.3mm}
\ttt{7}{7}{2}{line width=0.3mm}
\ttt{14}{7}{2}{line width=0.3mm}
\end{tikzpicture}
\end{center}
\vfill
\pagebreak
\end{document}

47
src/Warm-Ups/Wild Tic-Tac-Toe/main.typ
View File

@ -1,47 +0,0 @@
#import "@local/handout:0.1.0": *
#import "@preview/cetz:0.3.1"
#show: handout.with(
title: [Warm-Up: Wild Tic-Tac-Toe],
by: "Mark",
)
#let ttt = align(
center,
cetz.canvas({
import cetz.draw: *
let s = 0.7 // scale
set-style(stroke: (thickness: 0.5mm * s))
line((-1 * s, 3 * s), (-1 * s, -3 * s))
line((1 * s, 3 * s), (1 * s, -3 * s))
line((3 * s, -1 * s), (-3 * s, -1 * s))
line((3 * s, 1 * s), (-3 * s, 1 * s))
}),
)
#problem()
In wild tic-tac-toe, players may place either an X or O on each move. The player that first completes a
row of any three symbols wins. Show that the first player always has a winning strategy.
#v(4mm)
#table(
stroke: none,
align: center,
columns: (1fr, 1fr, 1fr),
ttt, ttt, ttt,
);
#v(1fr)
#problem()
Now, say the first player to complete a row loses. Who has a winning strategy now?
#v(4mm)
#table(
stroke: none,
align: center,
columns: (1fr, 1fr, 1fr),
ttt, ttt, ttt,
);
#v(1fr)

150
src/Warm-Ups/Zeno's Furniture/main.tex Executable file
View File

@ -0,0 +1,150 @@
\documentclass[
solutions,
singlenumbering,
nopagenumber
]{../../../lib/tex/ormc_handout}
\usepackage{../../../lib/tex/macros}
\makeatletter
\newcommand{\thisone}{
\if@solutions
{\color{red} $\Leftarrow$ \texttt{this one}}
\else\fi
}
\title{Zeno's Furniture}
\uptitlel{Warm Ups}
\uptitler{\smallurl{}}
\subtitle{Prepared by Mark on \today}
\begin{document}
\maketitle
Zeno Furniture sells exactly five types of furniture:
\begin{itemize}
\item Footstools
\item Hutches
\item Sideboards
\item Tables
\item Vanities
\end{itemize}
Irene buys four items, each of a different type,
and each made of exactly one kind of wood:
\begin{itemize}
\item Maple
\item Oak
\item Pine
\item Rosewood
\end{itemize}
The following conditions govern Irene's purchases:
\begin{itemize}
\item Any vanity she buys is Maple.
\item Any rosewood item she buys is a sideboard.
\item If she buys a vanity, she does not buy a footstool.
\item If she buys a footstool, she also buys a table made of the same material.
\item Irene does not buy an oak table.
\item Exactly two of the items she buys are made of the same kind of wood.
\end{itemize}
\problem{}
Which one of the following could be an accurate
list of the items Irene buys? \par
\begin{itemize}
\item maple footstool, maple hutch, rosewood sideboard, maple table
\item oak hutch, rosewood sideboard, pine table, oak vanity
\item rosewood hutch, maple sideboard, oak table, maple vanity
\item pine footstool, rosewood sideboard, pine table, maple vanity
\item maple footstool, pine hutch, oak sideboard, maple table \thisone{}
\end{itemize}
\vfill
\problem{}
If Irene buys one item made of rosewood and two items made
of maple, then which one of the following pairs could be two
of the items she buys?
\begin{itemize}
\item a rosewood sideboard and an oak footstool
\item an oak hutch and a pine sideboard
\item an oak hutch and a maple table \thisone{}
\item a maple sideboard and a maple vanity
\item a maple hutch and a maple table
\end{itemize}
\vfill
\pagebreak
\problem{}
Which one of the following is a complete and accurate list
of all the woods any footstool that Irene buys could be made of?
\begin{itemize}
\item maple, oak
\item maple, pine \thisone{}
\item maple, rosewood
\item maple, oak, pine
\item maple, oak, pine, rosewood
\end{itemize}
\vfill
\problem{}
Suppose Irene buys a footstool. Then which one of the following
is a complete and accurate list of items and any one of which she
could buy in maple?
\begin{itemize}
\item footstool, hutch, sideboard, table, vanity
\item footstool, hutch, sideboard, table \thisone{}
\item footstool, hutch, sideboard
\item footstool, hutch
\item footstool
\end{itemize}
\vfill
\problem{}
Which one of the following cannot be the two items Irene
buys that are made of the same wood as each other?
\begin{itemize}
\item footstool, hutch \thisone{}
\item hutch, sideboard
\item hutch, table
\item sideboard, vanity
\item table, vanity
\end{itemize}
\vfill
\pagebreak
\problem{}
If Irene does not buy an item made of maple, then each of the
following must be true except...
\begin{itemize}
\item Irene buys a footstool
\item Irene buys a pine hutch \thisone{}
\item Irene buys a rosewood sideboard
\item Irene buys exactly one item made of oak
\item Irene buys exactly two items made of pine
\end{itemize}
\vfill
\problem{}
Suppose the condition that Irene does not buy an oak table is
replaced with the condition that she does not buy a pine table.
If all the other conditions hold as originally given, which of the
following cannot be true?
\begin{itemize}
\item Irene buys an oak footstool.
\item Irene buys a hutch and a table made of the same wood.
\item Irene buys a vanity, but she does not buy an oak table.
\item Irene buys a maple table and an oak hutch.
\item Irene buys a rosewood sideboard and exactly two items made of pine. \thisone{}
\end{itemize}
\vfill
\pagebreak
\end{document}

125
src/Warm-Ups/Zeno's Furniture/main.typ
View File

@ -1,125 +0,0 @@
#import "@local/handout:0.1.0": *
#show: handout.with(
title: [Warm-Up: Zeno's Furniture],
by: "Mark",
)
#let thisone = if_solutions(
text(fill: ored, [#sym.arrow.l.double.long `this one`]),
)
Zeno's Furniture sells exactly five types of furniture: \
Footstools, Hutches, Sideboards, Tables, and Vanities.
#v(3mm)
Each can be made of exactly one kind of wood: \
Maple, Oak, Pine, or Rosewood
#v(3mm)
Irene buys four items, each of a different type. \
The following conditions govern Irene's purchases:
- Any vanity she buys is Maple.
- Any rosewood item she buys is a sideboard.
- If she buys a vanity, she does not buy a footstool.
- If she buys a footstool, she also buys a table made of the same material.
- Irene does not buy an oak table.
- Exactly two of the items she buys are made of the same kind of wood.
#v(5mm)
#problem()
Which one of the following could be an accurate
list of the items Irene buys? \
- maple footstool, maple hutch, rosewood sideboard, maple table
- oak hutch, rosewood sideboard, pine table, oak vanity
- rosewood hutch, maple sideboard, oak table, maple vanity
- pine footstool, rosewood sideboard, pine table, maple vanity
- maple footstool, pine hutch, oak sideboard, maple table #thisone
#v(1fr)
#problem()
If Irene buys one item made of rosewood and two items made
of maple, then which one of the following pairs could be two
of the items she buys?
- a rosewood sideboard and an oak footstool
- an oak hutch and a pine sideboard
- an oak hutch and a maple table #thisone
- a maple sideboard and a maple vanity
- a maple hutch and a maple table
#v(1fr)
#pagebreak()
#problem()
Which one of the following is a complete and accurate list
of all the woods any footstool that Irene buys could be made of?
- maple, oak
- maple, pine #thisone
- maple, rosewood
- maple, oak, pine
- maple, oak, pine, rosewood
#v(1fr)
#problem()
Suppose Irene buys a footstool. Then which one of the following
is a complete and accurate list of items and any one of which she
could buy in maple?
- footstool, hutch, sideboard, table, vanity
- footstool, hutch, sideboard, table #thisone
- footstool, hutch, sideboard
- footstool, hutch
- footstool
#v(1fr)
#problem()
Which one of the following cannot be the two items Irene
buys that are made of the same wood as each other?
- footstool, hutch #thisone
- hutch, sideboard
- hutch, table
- sideboard, vanity
- table, vanity
#v(1fr)
#pagebreak()
#problem()
If Irene does not buy an item made of maple, then each of the
following must be true except...
- Irene buys a footstool
- Irene buys a pine hutch #thisone
- Irene buys a rosewood sideboard
- Irene buys exactly one item made of oak
- Irene buys exactly two items made of pine
#v(1fr)
#problem()
Suppose the condition that Irene does not buy an oak table is
replaced with the condition that she does not buy a pine table.
If all the other conditions hold as originally given, which of the
following cannot be true?
- Irene buys an oak footstool.
- Irene buys a hutch and a table made of the same wood.
- Irene buys a vanity, but she does not buy an oak table.
- Irene buys a maple table and an oak hutch.
- Irene buys a rosewood sideboard and exactly two items made of pine. #thisone
#v(1fr)

22
src/Warm-Ups/fmod/main.tex Executable file
View File

@ -0,0 +1,22 @@
\documentclass[
solutions,
hidewarning,
singlenumbering,
nopagenumber
]{../../../lib/tex/ormc_handout}
\usepackage{../../../lib/tex/macros}
\title{Warm-Up: \texttt{fmod}}
\uptitler{\smallurl{}}
\subtitle{Prepared by Mark on \today.}
\begin{document}
\maketitle
\problem{}
I'm sure you're all familiar with how \texttt{mod(a, b)} and \texttt{remainder(a, b)} work with integers. \par
Devise an equivalent for floats (i.e, real numbers).
\end{document}

10
src/Warm-Ups/fmod/main.typ
View File

@ -1,10 +0,0 @@
#import "@local/handout:0.1.0": *
#show: handout.with(
title: [Warm-Up: `fmod`],
by: "Mark",
)
#problem()
I'm sure you're all familiar with how `mod(a, b)` and `remainder(a, b)` \ work when `a` and `b` are integers.
Devise an equivalent for floats (i.e, real numbers).

491
src/Warm-Ups/gear.svg Normal file
View File

File diff suppressed because one or more lines are too long
Side by Side

After

Width:  |  Height:  |  Size: 53 KiB

37
src/Warm-Ups/sin.tex Executable file
View File

@ -0,0 +1,37 @@
\documentclass[
solutions,
singlenumbering,
nopagenumber
]{../../../lib/tex/ormc_handout}
\usepackage{../../../lib/tex/macros}
\title{Warm-Up: Exact answers}
\uptitler{\smallurl{}}
\subtitle{Prepared by Mark on \today}
\begin{document}
\maketitle
Compute the exact value of $\sin(x^\circ)$ for as many integers $x \in [0, 90]$ as you can.
\generic{Helpful identities:}
This is not a complete list. In many cases, geometry is more helpful than algebra. \\
Note that the first identity is only valid if $\alpha \in [0, 90]$.
\vspace{2mm}
$\sin(\frac{\alpha}{2}) = \sqrt{\frac{1 - \cos(\alpha)}{2}}$ \\
$\sin(\alpha + \beta) = \sin(\alpha)\cos(\beta) + \cos(\alpha)\sin(\beta)$ \\
$\sin(3\alpha) = 3\sin(\alpha) - 4\sin(\alpha)^3$
\begin{solution}
The solutions to these get ugly quickly.
\vspace{5mm}
A good order to go in is 45, 30, 60, 15, 75, 36, 18, 3, 6, 72, 9, 1. \\
You should be able to get all of these using only geometry and the identities above.
\end{solution}
\end{document}

233
src/Warm-Ups/snake.tex Executable file
View File

@ -0,0 +1,233 @@
\documentclass[
solutions,
singlenumbering,
nopagenumber
]{../../../lib/tex/ormc_handout}
\usepackage{../../../lib/tex/macros}
\usepackage{ifthen}
\usetikzlibrary{arrows.meta}
\usetikzlibrary{shapes.geometric}
\usetikzlibrary{patterns}
% We put nodes in a separate layer, so we can
% slightly overlap with paths for a perfect fit
\pgfdeclarelayer{nodes}
\pgfdeclarelayer{path}
\pgfsetlayers{main,nodes}
% Layer settings
\tikzset{
% Layer hack, lets us write
% later = * in scopes.
layer/.style = {
execute at begin scope={\pgfonlayer{#1}},
execute at end scope={\endpgfonlayer}
},
%
% Arrowhead tweak
>={Latex[ width=2mm, length=2mm ]},
%
% Labels inside edges
label/.style = {
rectangle,
% For automatic red background in solutions
fill = \ORMCbgcolor,
draw = none,
rounded corners = 0mm
},
%
% Nodes
main/.style = {
draw,
circle,
fill = white,
line width = 0.4mm,
text width = 5mm,
align = center
},
accept/.style = {
draw,
circle,
fill = white,
double,
double distance = 0.5mm,
line width = 0.4mm,
text width = 5mm,
align = center
},
}
\title{Warm-Up: Snakes}
\uptitler{\smallurl{}}
\subtitle{Prepared by Mark on \today}
\begin{document}
\maketitle
\newcounter{mycounter}
\setcounter{mycounter}{0}
\newif\iftmp
\begin{center}
\begin{tikzpicture}[scale = 0.6]
\begin{scope}[layer = nodes]
\foreach \r in {1,3,5,7,9} {
\foreach \i in {1,...,10} {
\pgfmathparse{Mod(\i-1,10)}
\let\x\pgfmathresult
\pgfmathparse{div(\i-1,10) + \r}
\let\y\pgfmathresult
\pgfmathparse{(\r-1)*10+\i}
\let\z\pgfmathresult
\tmpfalse
\pgfmathapproxequalto{\z}{4}
\ifpgfmathcomparison\tmptrue
\else\pgfmathapproxequalto{\z}{5}
\ifpgfmathcomparison\tmptrue
\else\pgfmathapproxequalto{\z}{19}
\ifpgfmathcomparison\tmptrue
\else\pgfmathapproxequalto{\z}{21}
\ifpgfmathcomparison\tmptrue
\else\pgfmathapproxequalto{\z}{28}
\ifpgfmathcomparison\tmptrue
\else\pgfmathapproxequalto{\z}{31}
\ifpgfmathcomparison\tmptrue
\else\pgfmathapproxequalto{\z}{35}
\ifpgfmathcomparison\tmptrue
\else\pgfmathapproxequalto{\z}{44}
\ifpgfmathcomparison\tmptrue
\else\pgfmathapproxequalto{\z}{47}
\ifpgfmathcomparison\tmptrue
\else\pgfmathapproxequalto{\z}{52}
\ifpgfmathcomparison\tmptrue
\else\pgfmathapproxequalto{\z}{53}
\ifpgfmathcomparison\tmptrue
\else\pgfmathapproxequalto{\z}{59}
\ifpgfmathcomparison\tmptrue
\else\pgfmathapproxequalto{\z}{70}
\ifpgfmathcomparison\tmptrue
\else\pgfmathapproxequalto{\z}{76}
\ifpgfmathcomparison\tmptrue
\else\pgfmathapproxequalto{\z}{81}
\ifpgfmathcomparison\tmptrue
\else\pgfmathapproxequalto{\z}{88}
\ifpgfmathcomparison\tmptrue
\else\pgfmathapproxequalto{\z}{98}
\ifpgfmathcomparison\tmptrue
\fi\fi\fi\fi\fi\fi\fi\fi\fi\fi\fi\fi\fi\fi\fi\fi\fi
\stepcounter{mycounter}
\iftmp
\node[accept] (\arabic{mycounter}) at (2*\x, 2*\y) {
$\pgfmathprintnumber{\z}$
};
\else
\node[main] (\arabic{mycounter}) at (2*\x, 2*\y) {
$\pgfmathprintnumber{\z}$
};
\fi
}
\foreach \i in {1,...,10} {
\pgfmathparse{9 - Mod(\i-1,10)}
\let\x\pgfmathresult
\pgfmathparse{div(\i-1,10) + \r + 1}
\let\y\pgfmathresult
\pgfmathparse{\r*10+\i}
\let\z\pgfmathresult
\tmpfalse
\pgfmathapproxequalto{\z}{4}
\ifpgfmathcomparison\tmptrue
\else\pgfmathapproxequalto{\z}{5}
\ifpgfmathcomparison\tmptrue
\else\pgfmathapproxequalto{\z}{19}
\ifpgfmathcomparison\tmptrue
\else\pgfmathapproxequalto{\z}{21}
\ifpgfmathcomparison\tmptrue
\else\pgfmathapproxequalto{\z}{28}
\ifpgfmathcomparison\tmptrue
\else\pgfmathapproxequalto{\z}{31}
\ifpgfmathcomparison\tmptrue
\else\pgfmathapproxequalto{\z}{35}
\ifpgfmathcomparison\tmptrue
\else\pgfmathapproxequalto{\z}{44}
\ifpgfmathcomparison\tmptrue
\else\pgfmathapproxequalto{\z}{47}
\ifpgfmathcomparison\tmptrue
\else\pgfmathapproxequalto{\z}{52}
\ifpgfmathcomparison\tmptrue
\else\pgfmathapproxequalto{\z}{53}
\ifpgfmathcomparison\tmptrue
\else\pgfmathapproxequalto{\z}{59}
\ifpgfmathcomparison\tmptrue
\else\pgfmathapproxequalto{\z}{70}
\ifpgfmathcomparison\tmptrue
\else\pgfmathapproxequalto{\z}{76}
\ifpgfmathcomparison\tmptrue
\else\pgfmathapproxequalto{\z}{81}
\ifpgfmathcomparison\tmptrue
\else\pgfmathapproxequalto{\z}{88}
\ifpgfmathcomparison\tmptrue
\else\pgfmathapproxequalto{\z}{98}
\ifpgfmathcomparison\tmptrue
\fi\fi\fi\fi\fi\fi\fi\fi\fi\fi\fi\fi\fi\fi\fi\fi\fi
\stepcounter{mycounter}
\iftmp
\node[accept] (\arabic{mycounter}) at (2*\x, 2*\y) {
$\pgfmathprintnumber{\z}$
};
\else
\node[main] (\arabic{mycounter}) at (2*\x, 2*\y) {
$\pgfmathprintnumber{\z}$
};
\fi
}
}
\end{scope}
\draw[->, line width = 0.6mm, rounded corners = 2mm]
(4) -- +(1,0) -- +(1, 13) -- +(3, 13) -> (75);
\draw[->, line width = 0.6mm, rounded corners = 2mm]
(5) -- +(0,-1) -- +(1,-1) -- +(1,1) -- (15);
\draw[->, line width = 0.6mm, rounded corners = 2mm]
(19) -- +(1, 0) -- +(1, 5) -- + (-1, 5) -- (41);
\draw[->, line width = 0.6mm, rounded corners = 2mm]
(21) -- +(1, 0) -- +(1,-5) -- +(3, -5) -- (3);
\draw[->, line width = 0.6mm, rounded corners = 2mm]
(28) -- +(1,0) -- +(1,3) -- +(3,3) -- (50);
\draw[->, line width = 0.6mm, rounded corners = 2mm]
(31) -- +(1,0) -- +(1,-7) -- +(-3, -7) -- (8);
\draw[->, line width = 0.6mm, rounded corners = 2mm]
(35) -- +(-1,0) -- +(-1,11) -- (96);
\draw[->, line width = 0.6mm, rounded corners = 2mm]
(44) -- +(-1,0) -- +(-1,7) -- +(-3,7) -- (82);
\draw[->, line width = 0.6mm, rounded corners = 2mm]
(47) -- +(1,0) -- +(1,-3) -- +(5,-3) -- (30);
\draw[->, line width = 0.6mm, rounded corners = 2mm]
(52) -- +(-1, 0) -- +(-1, -1) -- +(-5,-1) -- +(-5,-5) -- +(-11,-5) -- (23);
\draw[->, line width = 0.6mm, rounded corners = 2mm]
(53) -- +(-1,0) -- +(-1,7) -- (94);
\draw[->, line width = 0.6mm, rounded corners = 2mm]
(59) -- +(-1, 0) -- +(-1,1) -- +(-3,1) -- +(-3,9) -- +(7, 9) -- (95);
\draw[->, line width = 0.6mm, rounded corners = 2mm]
(70) -- +(-1, 0) -- +(-1, 5) -- (91);
\draw[->, line width = 0.6mm, rounded corners = 2mm]
(76) -- +(-1, 0) -- +(-1,-1) -- +(-5,-1) -- +(-5,-5) -- +(-7,-5) -- (41);
\draw[->, line width = 0.6mm, rounded corners = 2mm]
(81) -- +(0, -1) -- +(3, -1) -- +(3, -3) -- (62);
\draw[->, line width = 0.6mm, rounded corners = 2mm]
(88) -- +(1, 0) -- +(1, -3) -- +(-1,-3) -- (67);
\draw[->, line width = 0.6mm, rounded corners = 2mm]
(98) -- +(0, 1.5) -- +(15.5, 1.5) -- +(15.5,-15) -- +(13, -15) -- (12);
\end{tikzpicture}
\end{center}
\end{document}

96
src/Warm-Ups/turing.tex Executable file
View File

@ -0,0 +1,96 @@
\documentclass[
solutions,
hidewarning,
singlenumbering,
nopagenumber
]{../../../lib/tex/ormc_handout}
\usepackage{../../../lib/tex/macros}
\title{Warm-Up: Turing Machine}
\uptitler{\smallurl{}}
\subtitle{Prepared by Mark on \today.}
\begin{document}
\maketitle
Consider a turing machine that understands the following instructions:
\begin{itemize}[itemsep=2mm]
\item \texttt{>}: Move the tape right
\item \texttt{<}: Move the tape left
\item \texttt{+}: Increment the value in the current cell by 1. \par
If the resulting value exceeds 255, wrap to 0.
\item \texttt{-}: Decrement the value in the current cell by 1. \par
If the resulting value is smaller than 0, wrap to 255.
\item \texttt{[}: If the the value of the current cell is 0, jump to the matching \texttt{]}. \par
Otherwise, jump to the next instruction.
\item \texttt{]}: If the value of the current cell is 0, jump to the next instruction. \par
Otherwise, jump back to the matching \texttt{[}.
\end{itemize}
For example, the program \texttt{+>++>+++>++++>-} will set the first five cells to $[1, 2, 3, 4, 255]$. \par
All other cells will be zero, since they were not modified.
\problem{}
What does the snippet \texttt{[-]} do? \par
Is this different from \texttt{[+]}?
\vfill
\problem{}
What does \texttt{[->+<]} do?
\begin{solution}
Move the value of this cell into the next cell
\end{solution}
\vfill
\problem{}
Write a program that adds the value of the current cell to the next cell. \par
You do not need to preserve the value of the current cell.
\vfill
\pagebreak
\problem{}
What does \texttt{[>]} do?
\begin{solution}
Finds the first zero cell to the right
\end{solution}
\vfill
\problem{}
Write a program that copies the value of the current cell into the next cell,
preserving its initial value. \par
\hint{You may use as many "scratch" cells as you want.}
\vfill
\problem{}
Write a program that computes the product of the current cell and the next cell.
\vfill
\problem{Bonus}
Write a program that computes the square of the current cell. \par
(If your program starts at a cell with value \texttt{7}, it should end at a cell with value \texttt{49}.)
\vfill
\problem{Bonus}
What does \texttt{+[>[<-]<[->+<]>]>} do?
\begin{solution}
Finds the first non-zero cell to the right
\end{solution}
\end{document}

6
tools/scripts/build.py
View File

@ -143,12 +143,10 @@ def build_typst(source_dir: Path, out_subdir: Path) -> IndexEntry | None:
[ [
TYPST_PATH, TYPST_PATH,
"compile", "compile",
"--package-path",
f"{ROOT}/lib/typst",
"--ignore-system-fonts", "--ignore-system-fonts",
"main.typ",
"--input", "--input",
"show_solutions=false", "show_solutions=false",
"main.typ",
f"{out}/{handout_file}", f"{out}/{handout_file}",
], ],
cwd=source_dir, cwd=source_dir,
@ -166,8 +164,6 @@ def build_typst(source_dir: Path, out_subdir: Path) -> IndexEntry | None:
[ [
TYPST_PATH, TYPST_PATH,
"compile", "compile",
"--package-path",
f"{ROOT}/lib/typst",
"--ignore-system-fonts", "--ignore-system-fonts",
"main.typ", "main.typ",
f"{out}/{solutions_file}", f"{out}/{solutions_file}",