text:
## Another Moebius Strip (cf. Meeks-Weber)

Drag to Rotate, Scroll the Mouse Wheel to Scale, Ctrl+Drag to Translate.
$m=5$

### Weierstrass Data (Double Cover of the Surface)

$M=\mathbb{C}\setminus\{0\},$ $g=z^2\frac{z^{2m-1}+1}{z^{2m-1}-1},\qquad \eta = i\frac{(z^{2m-1}-1)^2}{z^{2m+2}}dz,$ where $m$ is a positive integer.

format: plain


text:
# Rotating a line segment in 3D to a prescribed orientation

I have a general line segment with endpoints $(x_1,y_1,z_1)$ and $(x_2,y_2,z_2)$ referenced to a 3D Cartesian coordinate frame E. I wish to rotate this coordinate fram E to a new coordinate system F such that the new $x$-axis is parallel to this line segment.

Basically, I am looking for three unique Euler angles $(\alpha,\beta,\gamma)$, using the usual $z-y'-z''$ convention, in terms of the coordinates for the two endpoints in the original coordinate frame. Therefore, in the new coordinate frame, I will have three equations to satisfy: 1. $y_1''' = y_2'''$, 2. $z_1''' = z_2'''$, and 3. $(x_2'''- x_1''')^2 = (x_2 - x_1)^2 + (y_2 - y_1)^2 + (z_2 - z_1)^2$

• Is the use of Euler angles prescribed for the problem, or would you consider any representation of the rotation (e.g. quaternions)? – Muphrid Jan 9 '13 at 20:40
• Presumably, you want the rotation to be with the origin as the center? – Thomas Andrews Jan 9 '13 at 20:43
• Euler angles are prescribed. Is there a way to go from another representation of the rotation to Euler angles? – user56726 Jan 9 '13 at 20:44
• The origin of the original and transformed coordinate system must be the same. – user56726 Jan 9 '13 at 20:45

## 1 Answer

It's probably easier to think about this logically, then, rather than directly in terms of spinors/quaternions. Here's what you can do: you're rotating the $\hat x$ vector onto the vector $\hat \ell$. This can be done in a two-step process: rotate $\hat x$ onto $\hat \ell$'s projection onto the xy-plane. This puts $\hat \ell$ on the $zx'$ plane, and only one more rotation is required--rotation about $y'$--to line up $\hat x''$ with $\hat \ell$.

• Thanks, that's exactly what I've been trying to do for the past several hours, but something is wrong with my computation for arbitrary end points. – user56726 Jan 9 '13 at 21:48
• The computation should not care about the end points, only about the direction of the line itself. – Muphrid Jan 9 '13 at 22:11
• Yes, thanks. The problem is now solved and was a numerical issue with my algorithm instead of a problem with the underlying math. I am using the method you proposed and it works great. – user56726 Jan 10 '13 at 22:25


text:
# A Sudoku Web App Using CPLEX Python Modeling API¶

## Author: Jean-François Puget¶

We will be solving sudoku problems using docplex and the model from a post of mine.

We will use the Python client for the DOcloud service. It can be installed with pip.

# Initialization¶

First, let's group all imports at the beginning

In [1]:
from docplex.mp.model import Model
from docplex.mp.context import Context
from docplex.mp.environment import Environment

import numpy as np

import matplotlib.pyplot as plt
%matplotlib inline

import os
import json
import jinja2

Then let us initialize the Docloud connections. We print information to check the status. You will need to enter your credentials.

In [2]:
docloud_context = Context.make_default_context(url=url, key=api_key)

env = Environment()
env.print_information()

* system is: Windows 64bit
* Python is present, version is 3.4.3
* docplex is present, version is (1, 0, 455)
* CPLEX wrapper is not available

Seems everything is fine.

# Model creation¶

Let us model the sudoku problem. We will first describe the generic part of the model, i.e. the decision variables, the constraints, and the objective function that are independant from the input grid. We will then process the input grid to augment the model.

In [3]:
model = Model('sudoku_CPLEX', context=docloud_context)

Warning: CPLEX DLL not found, will solve on DOcloud

The warning tells us that we are not using a local CPLEX install.

## The variables¶

The logic of the model is rather simple. we create a three dimension matrix of binary variables.

Dimensions of the matrix are: rows, columns, and digits.

Rows and columns are the rows and columns of the Sudoku grid.
There are 9 variables per cell of the grid, representing each possible digit.

Binary variable sudoku[i][j][k] is 1 if and only if digit k+1 is placed on cell i,j. We use k+1 because indexing in Python starts at 0, while the digits start at 1.

In [4]:
rows    = range(0,9)
columns = range(0,9)
digits  = range(0,9)

We represent the matrix with Python arrays. Variable sudoku[i][j][k] is named x_i_j_k

In [5]:
sudoku = [[[model.binary_var("x_%d_%d_%d" % (i,j,k)) for k in digits] for j in columns] for i in rows]

## The constraints¶

Our first constraint is that there is exactly one digit per square

In [6]:
for i in rows:
for j in columns:

Our second constraint is that the digits on each line are different.

In [7]:
for i in rows:
for k in digits:
model.add_constraint(model.sum(sudoku[i][j][k] for j in columns)  == 1)

Our third constraint is that digits on each columns are different.

In [8]:
for j in columns:
for k in digits:
model.add_constraint(model.sum(sudoku[i][j][k] for i in rows) == 1)

Our last constraint is that digits in 3x3 blocks are different.

Expressing this one is a bit trickier. We need to get the list of variables in each 3x3 block, for a given digit.

Let's look at the first 3x3 block.

We can get the first 3 rows with sudoku[0:3] We then get the first three columns for each row with [c[0:3] for c in sudoku[0:3]]

This yields a list (rows) of lists (columns). We can use the overloaded sum operator to flatten the lists: sum([c[0:3] for c in sudoku[0:3]],[])

All digits in that block must be different. We collect the variables for a fixed digit k in this list, and we express that their sum is less than 1.

block_list = [c[0:3] for c in sudoku[0:3]] block = sum(block_list,[]) for k in digits: model.add_constraint(sum(c[k] for c in block) == 1)

We repeat the above for each 3x3 block, iterating on block rows and bloc columns

In [9]:
for block_row in range(0,3):
for block_column in range(0,3):
block_list = [cell[3*block_column:3*(block_column+1)] \
for cell in sudoku[3*block_row:3*(block_row+1)]]
block = sum (block_list, [])
for k in digits:
model.add_constraint(sum(c[k] for c in block) == 1)

## The objective¶

Sudoku is a satisfaction problem, we only look for a feasible solution. There is no objective, hence the generic part of our model is complete.

# Problem input¶

Let us now look at the input of our web app. Input will be a string of the entries in the sudoku grid. If a cell is empty we accept either 0 or . as input. if a key is provided, then we accept the key itself. We can also have formatting characters, these will be stripped during processing. Here are two possible inputs, for one of the hard sudoku grid there is. Both input define the same problem to solve.

In [10]:
input1 = """
. . . |. . 6 |. . .
. 5 9 |. . . |. . 8
2 . . |. . 8 |. . .
------+------+------
. 4 5 |. . . |. . .
. . 3 |. . . |. . .
. . 6 |. . 3 |. 5 4
------+------+------
. . . |3 2 5 |. . 6
. . . |. . . |. . .
. . . |. . . |. . .
"""

input2 = '.....6....59.....82....8....45........3........6..3.54...325..6..................'

List comprehensions can be used to remove all non numerical characters, and replace dots by 0.

In [11]:
def sudoku_trim(input):
chars = ['0' if c == '.' else c for c in input if c in '.0123456789']
return ''.join(chars)

We also need to move back and forth between the string input and a 2D matric of integers like the following.

[[0,0,0,0,0,6,0,0,0],
[0,5,9,0,0,0,0,0,8],
[2,0,0,0,0,8,0,0,0],
[0,4,5,0,0,0,0,0,0],
[0,0,3,0,0,0,0,0,0],
[0,0,6,0,0,3,0,5,4],
[0,0,0,3,2,5,0,0,6],
[0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0]]

List comprehensions do a nice job here too.

In [12]:
def sudoku_string2int (input):
chars = [0 if c == '.' else int(c) for c in input if c in '.0123456789']
grid = [chars[i*9:(i+1)*9] for i in range(0,9)]
return grid

def sudoku_int2string (solution):
flat_solution = sum(solution, [])
values = [str(cell) for cell in flat_solution]
return ''.join(values)

Let's try them

In [13]:
sudoku_trim(input1)

Out[13]:
'000006000059000008200008000045000000003000000006003054000325006000000000000000000'
In [14]:
sudoku_trim(input2)

Out[14]:
'000006000059000008200008000045000000003000000006003054000325006000000000000000000'
In [15]:
sudoku_int2string(sudoku_string2int(input1))

Out[15]:
'000006000059000008200008000045000000003000000006003054000325006000000000000000000'
In [16]:
grid = sudoku_string2int(input1)
grid

Out[16]:
[[0, 0, 0, 0, 0, 6, 0, 0, 0],
[0, 5, 9, 0, 0, 0, 0, 0, 8],
[2, 0, 0, 0, 0, 8, 0, 0, 0],
[0, 4, 5, 0, 0, 0, 0, 0, 0],
[0, 0, 3, 0, 0, 0, 0, 0, 0],
[0, 0, 6, 0, 0, 3, 0, 5, 4],
[0, 0, 0, 3, 2, 5, 0, 0, 6],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0]]

In order to solve that grid, we need to state that the non null entries define the corresponding binary variable: sudoku[i][j][k] is 1 if and only if digit k+1 is placed on cell i,j.

In [17]:
for i in rows:
for j in columns:
if grid[i][j] > 0:
k = grid[i][j] - 1

# Solving the input problem¶

We can now solve the problem. We print information about the model before and after solving it

In [18]:
model.print_information()
model.export_as_lp()
model.solve()
model.report()

Model: sudoku_CPLEX
- number of variables: 729
- binary=729, integer=0, continuous=0
- number of constraints: 341
-   LE=0, EQ=341, GE=0, RNG=0
- parameters: defaults
* No objective to optimize - searching for a feasible solution
* model solved with objective: 1

The problem is solved. We can now retrieve the solution as a 3D matrix.

In [19]:
raw_solution = [[[sudoku[i][j][k].solution_value for k in digits] for j in columns] for i in rows]

Digit in the first cell:

In [20]:
raw_solution[0][0]

Out[20]:
[0, 0, 0, 1, 0, 0, 0, 0, 0]

This is not very readable unfortunately. We need to map this to a digit. More generally, we need to map the raw solution to a 2D Sudoku grid. For that we need to replace the innermost arrays of 9 binary variables by the digit it represents. We do this by a numpy dot product

In [21]:
solution = [[1+np.dot(raw_solution[i][j],digits) for j in columns] for i in rows]

solution

Out[21]:
[[4, 8, 1, 9, 3, 6, 5, 2, 7],
[3, 5, 9, 2, 7, 1, 6, 4, 8],
[2, 6, 7, 4, 5, 8, 1, 9, 3],
[7, 4, 5, 6, 9, 2, 3, 8, 1],
[8, 1, 3, 5, 4, 7, 2, 6, 9],
[9, 2, 6, 8, 1, 3, 7, 5, 4],
[1, 9, 4, 3, 2, 5, 8, 7, 6],
[5, 3, 8, 7, 6, 9, 4, 1, 2],
[6, 7, 2, 1, 8, 4, 9, 3, 5]]

Seems our code is working! Let us pretty print the result using matplotlib.

In [22]:
fig, ax = plt.subplots(figsize =(4,4))

for i in rows:
for j in columns:
ax.text(i+0.5,8.5-j, str(solution[j][i]), va='center', ha='center')

ax.set_xlim(0, 9)
ax.set_ylim(0, 9)
ax.set_xticks(rows)
ax.set_yticks(columns)
ax.grid()
plt.show()

# Wrapping up¶

Let's wrap everything into an easy to reuse function

In [23]:
def sudoku_solve(docloud_context, input):
model = Model('sudoku_CPLEX', context=docloud_context)

rows    = range(0,9)
columns = range(0,9)
digits  = range(0,9)

sudoku = [[[model.binary_var("x_%d_%d_%d" % (i,j,k)) for k in digits] for j in columns] for i in rows]

for i in rows:
for j in columns:

for i in rows:
for k in digits:
model.add_constraint(model.sum(sudoku[i][j][k] for j in columns)  == 1)

for j in columns:
for k in digits:
model.add_constraint(model.sum(sudoku[i][j][k] for i in rows) == 1)

for block_row in range(0,3):
for block_column in range(0,3):
block_list = [cell[3*block_column:3*(block_column+1)] for cell in sudoku[3*block_row:3*(block_row+1)]]
block = sum (block_list, [])
for k in digits:
model.add_constraint(sum(c[k] for c in block) == 1)

grid = sudoku_string2int(input)

for i in rows:
for j in columns:
if grid[i][j] > 0:
k = grid[i][j] - 1

model.export_as_lp()
if not model.solve():
#Problem has no solution
return []

raw_solution = [[[sudoku[i][j][k].solution_value for k in digits] for j in columns] for i in rows]
solution = [[1+np.dot(raw_solution[i][j], digits) for j in columns] for i in rows]
return solution

Let us test our function.

In [24]:
input = """
. . . |. . 6 |. . .
. 5 9 |. . . |. . 8
2 . . |. . 8 |. . .
------+------+------
. 4 5 |. . . |. . .
. . 3 |. . . |. . .
. . 6 |. . 3 |. 5 4
------+------+------
. . . |3 2 5 |. . 6
. . . |. . . |. . .
. . . |. . . |. . .
"""

solution = sudoku_solve(docloud_context, input)

solution

Warning: CPLEX DLL not found, will solve on DOcloud
* No objective to optimize - searching for a feasible solution

Out[24]:
[[3, 8, 7, 4, 5, 6, 9, 2, 1],
[4, 5, 9, 2, 7, 1, 6, 3, 8],
[2, 6, 1, 9, 3, 8, 4, 7, 5],
[9, 4, 5, 8, 1, 2, 7, 6, 3],
[7, 1, 3, 5, 6, 4, 2, 8, 9],
[8, 2, 6, 7, 9, 3, 1, 5, 4],
[1, 7, 4, 3, 2, 5, 8, 9, 6],
[5, 9, 8, 6, 4, 7, 3, 1, 2],
[6, 3, 2, 1, 8, 9, 5, 4, 7]]

# A web app¶

We now turn this into a web app reusing the code from A Sudoku Web App Based On DOcloud And Python

We define the input web page as a template because we do not want to hard code the service url in it. We will pass it as argument to the template.

In [25]:
page = jinja2.Template(r"""

<title>A Sudoku Solver</title>

A Sudoku Solver

Fill the grid with at least 15 hints

<input type="button" id="solve" value="Solve" onClick="solve_grid();"> <input type="button" id="clear" value="Clear" onClick="clear_grid();">

""")

The base url of the service is queried as we do not want to assume anything about where this web app will be deployed. We will use one port on that base url. We selected port 9000 but any other one is useable provided it is exposed.

In [26]:
PORT = 9000

host = os.getenv('HOST_PUBLIC_IP')

if host == None: host = 'localhost'

url = 'http://%s:%d' % (host , PORT)

Let's see what we get.

In [27]:
print(url)

http://localhost:9000

So far so good, we will click on the above url to launch our web app. Before we do that, we need to run a server for it. Easiest way is to use Flask.

We can now create the web service with Flask.

In [28]:
flask_app = Flask('sudoku_demo')

def index():
'''Renders the template with the service url and an initial grid on HTTP GET.'''
return page.render(url=url, input=sudoku_trim(input))

def solve():
'''Solves the input Sudoku and returns it on HTTP GET.'''
input = request.args.get('grid', '')
solution = sudoku_solve(docloud_context, input)
result = sudoku_int2string(solution)
return jsonify(result=result)

In [29]:
#flask_app.run(host='0.0.0.0', port=PORT)

The run command above blocks the notebook kernel from returning for as long as the web server is running. To stop the server, we need to interrupt the kernel (KernelInterrupt).

We can run the Flask application in a Tornado WSGIContainer if we want a non blocking web server.

In [30]:
server = tornado.httpserver.HTTPServer(WSGIContainer(flask_app))
server.listen(PORT, '0.0.0.0')

Warning: CPLEX DLL not found, will solve on DOcloud
* No objective to optimize - searching for a feasible solution

This concludes our web ap development. To run the web app, simply click on the url above.

This web app can be deployed on any iPython notebook server. For instance we have shown how to deploy a similar web app on bluemix using a Docker container in Deploy IPython Notebooks With Docker On Bluemix In Minutes

In [ ]:


text:
# Tomasz Kochanek: Bases of Banach spaces with respect to filters

Seminar: Working group in applications of set theory, IMPAN

Thursday, 22.11. 2018, 10:15, room 105, IMPAN

Speaker: Tomasz Kochanek (IM PAN / MIM UW)

Title: “Bases of Banach spaces with respect to filters”

Abstact: “In 2011, Vladimir Kadets proposed the following problem: Given a filter F of subsets of natural numbers and a Banach space X, we say that a sequence (e_n) in X forms an F-basis, provided that every x in X has a unique representation as a series of linear combinations of e_n’s, where the convergence is understood in the norm topology and with respect to F. Thus, for F being the filter of cofinite sets we obtain the classical notion of Schauder basis for which it is well-known that all the coordinate functionals are automatically continuous. The question is whether, they must be continuous for a general filter F. I shall present a positive answer to this questions in the case where the character of F is smaller than the pseudointersection number (published in Studia Math. 2012). Unfortunately, the answer is still not known in the important case where F is the statistical filter consisting of all sets of asymptotic density 1. We will also discuss some other related open problems concerning bases with brackets and with individual brackets”.

Visit our seminar page which may include some future talks at https://www.impan.pl/~set_theory/Seminar/

This site uses Akismet to reduce spam. Learn how your comment data is processed.


text:
# Properties of a Parallelogram - Theorem: If in a Quadrilateral, Each Pair of Opposite Angles is Equal, Then It is a Parallelogram.

#### theorem

Theorem:  If in a quadrilateral, each pair of opposite angles is equal, then it is a parallelogram.
∠A = ∠D
=> ∠A +∠B +∠C + ∠D
Now, ∠A +∠B +∠C + ∠D = 360°  (angle sum property of quadrilateral)
=> 2(∠A +∠B ) = 360°
=>  ∠A +∠B  = 180°
therefore ∠A +∠B  = ∠C + ∠D = 180°
Line AB intersects AD and BC at A and B respectively.
Such that ∠A +∠B = 180°
therefore  AD || BC   (Sum of consecutive interior angle is 180° ) ...(1)
∠A +∠B  = 180°
∠A +∠D  = 180°     (∠B= ∠D)
therefore  AB || CD  ..(2)
From (1) and (2), we get
AB || CD and AD || BC
therefore ABCD is a parallelogram.

If you would like to contribute notes or other learning material, please submit them using the button below.

### Shaalaa.com

Theorem : If in a quadrilateral, each pair of opposite angles is equal, then it is a parallelogram. [00:13:07]
S


text:
# Dirichlet Problem for Laplace's Equation Outside of a Disc

#### nonsequitter

##### New member
The Poisson Integral Formula is a representation of the bounded solution of the Dirichlet problem for Laplace's equation in the interior of the disc. Derive the corresponding formula
for the Dirichlet problem in the exterior of the disc, again assuming that the solution is bounded.

So we derived the expression for the interior part of a disc in class: $u(r,\theta)=\frac{1}{2\pi}\int_0^{2\pi}g(\phi) \frac{b^2-r^2}{b^2-2brcos(\theta-\phi)+r^2} d\phi$, where b is the radius of the disc and $u(b,\theta)=g(\theta)$. It was fairly straightforward, except that we were able to just assume the form of the solution $u(r,\theta)=\frac{1}{2}\gamma_0 +\sum_{n=1}^{\infty} (\frac{r}{b})^n[\gamma_ncos(n\theta)+\delta_nsin(n\theta)]$, where $\gamma_n=\frac{1}{\pi}\int_{0}^{2\pi}g(\phi)cos(n\phi)d\phi$ and $\delta_n=\frac{1}{\pi}\int_{0}^{2\pi}g(\phi)sin(n\phi)d\phi$. We then played around with the sums of the series of sin and cos and took the real part of that to get our answer.

Now, for the exterior of the disc, I'm just not sure how to start off with the form of the solution. It seems like the $(\frac{r}{b})^n$ should really be the only difference, but I can't justify randomly picking a form. Any suggestions?

#### Jester

##### Well-known member
MHB Math Helper
My first thought is to try the transformation $r \to \dfrac{1}{r}$ and see where that takes you.


text:
### Magnetism and Thermodynamics of Spin-1/2 Heisenberg Diamond Chains in a Magnetic Field

Bo Gu and Gang Su

Bo Gu update to 2009-11-13

https://arxiv.org/abs/0704.0150
The magnetic and thermodynamic properties of spin-1/2 Heisenberg diamondchains are investigated in three different cases: (a) J1, J2, J3>0(frustrated); (b) J1, J3<0, J2>0 (frustrated); and (c) J1, J2>0, J3<0(non-frustrated). The density matrix renormalization group (DMRG) technique isinvoked to study the properties of the system in the ground state, while thetransfer matrix renormalization group (TMRG) technique is applied to explorethe thermodynamic properties. The local magnetic moments, spin correlationfunctions, and static structure factors are discussed in the ground state forthe three cases. It is shown that the static structure factor S(q) shows peaksat wavevectors $q=a\pi /3$ (a=0,1,2,3,4,5) for different couplings in a zeromagnetic field, which, however in the magnetic fields where the magnetizationplateau with m=1/6 pertains, exhibits the peaks only at q=0, $2\pi /3$ and$4\pi /3$, which are found to be couplings-independent. The DMRG results of thezero-field static structure factor can be nicely fitted by a linearsuperposition of six modes, where two fitting equations are proposed. It isobserved that the six modes are closely related to the low-lying excitations ofthe system. At finite temperatures, the double-peak structures of thesusceptibility and specific heat against temperature are obtained, where thepeak positions and heights are found to depend on the competition of thecouplings. It is also uncovered that the XXZ anisotropy of F and AF couplingsleads the system of case (c) to display quite different behaviors. In addition,the experimental data of the susceptibility, specific heat and magnetizationfor the compound Cu$_{3}$(CO$_{3}$)$_{2}$(OH)$_{2}$ are fairly compared withour TMRG results.

journal: Phys. Rev. B 75, 174437 (2007)

category: cond-mat.str-el

### 自旋 1/2 海森堡钻石链的磁性和热力学 磁场

Bo Gu and Gang Su

Bo Gu update to 2009-11-13

https://arxiv.org/abs/0704.0150

category: cond-mat.str-el


text:
This is “Acids and Bases”, section 2.5 from the book Principles of General Chemistry (v. 1.0M). For details on it (including licensing), click here.

Has this book helped you? Consider passing it on:
Creative Commons supports free culture from music to education. Their licenses helped make this book available to you.
DonorsChoose.org helps people like you help teachers fund their classroom projects, from art supplies to books to calculators.

## 2.5 Acids and Bases

### Learning Objective

1. To identify and name some common acids and bases.

For our purposes at this point in the text, we can define an acidA substance with at least one hydrogen atom that can dissociate to form an anion and an $H+$ ion (a proton) in aqueous solution, thereby foming an acidic solution. as a substance with at least one hydrogen atom that can dissociate to form an anion and an H+ ion (a proton) in aqueous solution, thereby forming an acidic solution. We can define basesA substance that produces one or more hydroxide ions $(OH−)$ and a cation when dissolved in aqueous solution, thereby forming a basic solution. as compounds that produce hydroxide ions (OH) and a cation when dissolved in water, thus forming a basic solution. Solutions that are neither basic nor acidic are neutral. We will discuss the chemistry of acids and bases in more detail in Chapter 4 "Reactions in Aqueous Solution", Chapter 8 "Ionic versus Covalent Bonding", and Chapter 16 "Aqueous Acid–Base Equilibriums", but in this section we describe the nomenclature of common acids and identify some important bases so that you can recognize them in future discussions. Pure acids and bases and their concentrated aqueous solutions are commonly encountered in the laboratory. They are usually highly corrosive, so they must be handled with care.

## Acids

The names of acids differentiate between (1) acids in which the H+ ion is attached to an oxygen atom of a polyatomic anion (these are called oxoacidsAn acid in which the dissociable $H+$ ion is attached to an oxygen atom of a polyatomic anion., or occasionally oxyacids) and (2) acids in which the H+ ion is attached to some other element. In the latter case, the name of the acid begins with hydro- and ends in -ic, with the root of the name of the other element or ion in between. Recall that the name of the anion derived from this kind of acid always ends in -ide. Thus hydrogen chloride (HCl) gas dissolves in water to form hydrochloric acid (which contains H+ and Cl ions), hydrogen cyanide (HCN) gas forms hydrocyanic acid (which contains H+ and CN ions), and so forth (Table 2.8 "Some Common Acids That Do Not Contain Oxygen"). Examples of this kind of acid are commonly encountered and very important. For instance, your stomach contains a dilute solution of hydrochloric acid to help digest food. When the mechanisms that prevent the stomach from digesting itself malfunction, the acid destroys the lining of the stomach and an ulcer forms.

### Note the Pattern

Acids are distinguished by whether the H+ ion is attached to an oxygen atom of a polyatomic anion or some other element.

Table 2.8 Some Common Acids That Do Not Contain Oxygen

Formula Name in Aqueous Solution Name of Gaseous Species
HF hydrofluoric acid hydrogen fluoride
HCl hydrochloric acid hydrogen chloride
HBr hydrobromic acid hydrogen bromide
HI hydroiodic acid hydrogen iodide
HCN hydrocyanic acid hydrogen cyanide
H2S hydrosulfuric acid hydrogen sulfide

If an acid contains one or more H+ ions attached to oxygen, it is a derivative of one of the common oxoanions, such as sulfate (SO42−) or nitrate (NO3). These acids contain as many H+ ions as are necessary to balance the negative charge on the anion, resulting in a neutral species such as H2SO4 and HNO3.

The names of acids are derived from the names of anions according to the following rules:

1. If the name of the anion ends in -ate, then the name of the acid ends in -ic. For example, because NO3 is the nitrate ion, HNO3 is nitric acid. Similarly, ClO4 is the perchlorate ion, so HClO4 is perchloric acid. Two important acids are sulfuric acid (H2SO4) from the sulfate ion (SO42−) and phosphoric acid (H3PO4) from the phosphate ion (PO43−). These two names use a slight variant of the root of the anion name: sulfate becomes sulfuric and phosphate becomes phosphoric.
2. If the name of the anion ends in -ite, then the name of the acid ends in -ous. For example, OCl is the hypochlorite ion, and HOCl is hypochlorous acid; NO2 is the nitrite ion, and HNO2 is nitrous acid; and SO32− is the sulfite ion, and H2SO3 is sulfurous acid. The same roots are used whether the acid name ends in -ic or -ous; thus, sulfite becomes sulfurous.

The relationship between the names of the oxoacids and the parent oxoanions is illustrated in Figure 2.20 "The Relationship between the Names of the Oxoacids and the Names of the Parent Oxoanions", and some common oxoacids are in Table 2.9 "Some Common Oxoacids".

Figure 2.20 The Relationship between the Names of the Oxoacids and the Names of the Parent Oxoanions

Table 2.9 Some Common Oxoacids

Formula Name
HNO2 nitrous acid
HNO3 nitric acid
H2SO3 sulfurous acid
H2SO4 sulfuric acid
H3PO4 phosphoric acid
H2CO3 carbonic acid
HClO hypochlorous acid
HClO2 chlorous acid
HClO3 chloric acid
HClO4 perchloric acid

### Example 11

Name and give the formula for each acid.

1. the acid formed by adding a proton to the hypobromite ion (OBr)
2. the acid formed by adding two protons to the selenate ion (SeO42−)

Given: anion

Strategy:

Refer to Table 2.8 "Some Common Acids That Do Not Contain Oxygen" and Table 2.9 "Some Common Oxoacids" to find the name of the acid. If the acid is not listed, use the guidelines given previously.

Solution:

Neither species is listed in Table 2.8 "Some Common Acids That Do Not Contain Oxygen" or Table 2.9 "Some Common Oxoacids", so we must use the information given previously to derive the name of the acid from the name of the polyatomic anion.

1. The anion name, hypobromite, ends in -ite, so the name of the parent acid ends in -ous. The acid is therefore hypobromous acid (HOBr).
2. Selenate ends in -ate, so the name of the parent acid ends in -ic. The acid is therefore selenic acid (H2SeO4).

Exercise

Name and give the formula for each acid.

1. the acid formed by adding a proton to the perbromate ion (BrO4)
2. the acid formed by adding three protons to the arsenite ion (AsO33−)

1. perbromic acid; HBrO4
2. arsenous acid; H3AsO3

Many organic compounds contain the carbonyl groupA carbon atom double-bonded to an oxygen atom. It is a characteristic feature of many organic compounds, including carboxylic acids., in which there is a carbon–oxygen double bond. In carboxylic acidsAn organic compound that contains an −OH group covalently bonded to the carbon atom of a carbonyl group. The general formula of a carboxylic acid is $RCO2H$. In water a carboxylic acid dissociates to produce an acidic solution., an –OH group is covalently bonded to the carbon atom of the carbonyl group. Their general formula is RCO2H, sometimes written as RCOOH:

where R can be an alkyl group, an aryl group, or a hydrogen atom. The simplest example, HCO2H, is formic acid, so called because it is found in the secretions of stinging ants (from the Latin formica, meaning “ant”). Another example is acetic acid (CH3CO2H), which is found in vinegar. Like many acids, carboxylic acids tend to have sharp odors. For example, butyric acid (CH3CH2CH2CO2H), is responsible for the smell of rancid butter, and the characteristic odor of sour milk and vomit is due to lactic acid [CH3CH(OH)CO2H]. Some common carboxylic acids are shown in Figure 2.21 "Some Common Carboxylic Acids".

Figure 2.21 Some Common Carboxylic Acids

Although carboxylic acids are covalent compounds, when they dissolve in water, they dissociate to produce H+ ions (just like any other acid) and RCO2 ions. Note that only the hydrogen attached to the oxygen atom of the CO2 group dissociates to form an H+ ion. In contrast, the hydrogen atom attached to the oxygen atom of an alcohol does not dissociate to form an H+ ion when an alcohol is dissolved in water. The reasons for the difference in behavior between carboxylic acids and alcohols will be discussed in Chapter 8 "Ionic versus Covalent Bonding".

### Note the Pattern

Only the hydrogen attached to the oxygen atom of the CO2 group dissociates to form an H+ ion.

## Bases

We will present more comprehensive definitions of bases in later chapters, but virtually every base you encounter in the meantime will be an ionic compound, such as sodium hydroxide (NaOH) and barium hydroxide [Ba(OH)2], that contain the hydroxide ion and a metal cation. These have the general formula M(OH)n. It is important to recognize that alcohols, with the general formula ROH, are covalent compounds, not ionic compounds; consequently, they do not dissociate in water to form a basic solution (containing OH ions). When a base reacts with any of the acids we have discussed, it accepts a proton (H+). For example, the hydroxide ion (OH) accepts a proton to form H2O. Thus bases are also referred to as proton acceptors.

Concentrated aqueous solutions of ammonia (NH3) contain significant amounts of the hydroxide ion, even though the dissolved substance is not primarily ammonium hydroxide (NH4OH) as is often stated on the label. Thus aqueous ammonia solution is also a common base. Replacing a hydrogen atom of NH3 with an alkyl group results in an amineAn organic compound that has the general formula $RNH2$, where R is an alkyl group. Amines, like ammonia, are bases. (RNH2), which is also a base. Amines have pungent odors—for example, methylamine (CH3NH2) is one of the compounds responsible for the foul odor associated with spoiled fish. The physiological importance of amines is suggested in the word vitamin, which is derived from the phrase vital amines. The word was coined to describe dietary substances that were effective at preventing scurvy, rickets, and other diseases because these substances were assumed to be amines. Subsequently, some vitamins have indeed been confirmed to be amines.

### Note the Pattern

Metal hydroxides (MOH) yield OH ions and are bases, alcohols (ROH) do not yield OH or H+ ions and are neutral, and carboxylic acids (RCO2H) yield H+ ions and are acids.

### Summary

Common acids and the polyatomic anions derived from them have their own names and rules for nomenclature. The nomenclature of acids differentiates between oxoacids, in which the H+ ion is attached to an oxygen atom of a polyatomic ion, and acids in which the H+ ion is attached to another element. Carboxylic acids are an important class of organic acids. Ammonia is an important base, as are its organic derivatives, the amines.

### Key Takeaway

• Common acids and polyatomic anions derived from them have their own names and rules for nomenclature.

### Conceptual Problems

1. Name each acid.

1. HCl
2. HBrO3
3. HNO3
4. H2SO4
5. HIO3
2. Name each acid.

1. HBr
2. H2SO3
3. HClO3
4. HCN
5. H3PO4
3. Name the aqueous acid that corresponds to each gaseous species.

1. hydrogen bromide
2. hydrogen cyanide
3. hydrogen iodide
4. For each structural formula, write the condensed formula and the name of the compound.

1.

2.

5. For each structural formula, write the condensed formula and the name of the compound.

1.

2.

6. When each compound is added to water, is the resulting solution acidic, neutral, or basic?

1. CH3CH2OH
2. Mg(OH)2
3. C6H5CO2H
4. LiOH
5. C3H7CO2H
6. H2SO4
7. Draw the structure of the simplest example of each type of compound.

1. alkane
2. alkene
3. alkyne
4. aromatic hydrocarbon
5. alcohol
6. carboxylic acid
7. amine
8. cycloalkane
8. Identify the class of organic compound represented by each compound.

1.

2. CH3CH2OH
3. HC≡CH
4.

5. C3H7NH2
6. CH3CH=CHCH2CH3
7.

8.

9. Identify the class of organic compound represented by each compound.

1.

2.

3.

4.

5.

6. CH3C≡CH
7.

8.

### Numerical Problems

1. Write the formula for each compound.

1. hypochlorous acid
2. perbromic acid
3. hydrobromic acid
4. sulfurous acid
5. sodium perbromate
2. Write the formula for each compound.

1. hydroiodic acid
2. hydrogen sulfide
3. phosphorous acid
4. perchloric acid
5. calcium hypobromite
3. Name each compound.

1. HBr
2. H2SO3
3. HCN
4. HClO4
5. NaHSO4
4. Name each compound.

1. H2SO4
2. HNO2
3. K2HPO4
4. H3PO3
5. Ca(H2PO4)2·H2O


text:
# Large numbers

This article is about large numbers in the sense of numbers that are significantly larger than those ordinarily used in everyday life, for instance in simple counting or in monetary transactions. The term typically refers to large positive integers, or more generally, large positive real numbers, but it may also be used in other contexts.

Very large numbers often occur in fields such as mathematics, cosmology, cryptography, and statistical mechanics. Sometimes people refer to numbers as being "astronomically large". However, it is easy to mathematically define numbers that are much larger even than those used in astronomy.

## Using scientific notation to handle large and small numbers

Scientific notation was created to handle the wide range of values that occur in scientific study. 1.0 × 109, for example, means one billion, a 1 followed by nine zeros: 1 000 000 000, and 1.0 × 10−9 means one billionth, or 0.000 000 001. Writing 109 instead of nine zeros saves readers the effort and hazard of counting a long series of zeros to see how large the number is.

## Large numbers in the everyday world

Examples of large numbers describing everyday real-world objects are:

• The number of bits on a computer hard disk (as of 2010, typically about 1013, 500-1000 GB)
• The estimated number of atoms in the observable Universe (1080)
• The number of cells in the human body (more than 1014)
• The number of neuronal connections in the human brain (estimated at 1014)
• The Avogadro constant, the number of "elementary entities" (usually atoms or molecules) in one mole; the number of atoms in 12 grams of carbon-12; (approximately 6.022 × 1023 per mole)

## Astronomically large numbers

Other large numbers, as regards length and time, are found in astronomy and cosmology. For example, the current Big Bang model suggests that the Universe is 13.8 billion years (4.355 × 1017 seconds) old, and that the observable universe is 93 billion light years across (8.8 × 1026 metres), and contains about 5 × 1022 stars, organized into around 125 billion (1.25 × 1011) galaxies, according to Hubble Space Telescope observations. There are about 1080 atoms in the observable universe, by rough estimation.[1]

According to Don Page, physicist at the University of Alberta, Canada, the longest finite time that has so far been explicitly calculated by any physicist is

$10^{10^{10^{10^{10^{1.1}}}}} \mbox{ years}$

which corresponds to the scale of an estimated Poincaré recurrence time for the quantum state of a hypothetical box containing a black hole with the estimated mass of the entire universe, observable or not, assuming a certain inflationary model with an inflaton whose mass is 10−6 Planck masses.[2][3] This time assumes a statistical model subject to Poincaré recurrence. A much simplified way of thinking about this time is in a model where our universe's history repeats itself arbitrarily many times due to properties of statistical mechanics; this is the time scale when it will first be somewhat similar (for a reasonable choice of "similar") to its current state again.

Combinatorial processes rapidly generate even larger numbers. The factorial function, which defines the number of permutations on a set of fixed objects, grows very rapidly with the number of objects. Stirling's formula gives a precise asymptotic expression for this rate of growth.

Combinatorial processes generate very large numbers in statistical mechanics. These numbers are so large that they are typically only referred to using their logarithms.

Gödel numbers, and similar numbers used to represent bit-strings in algorithmic information theory, are very large, even for mathematical statements of reasonable length. However, some pathological numbers are even larger than the Gödel numbers of typical mathematical propositions.

Logician Harvey Friedman has done work related to very large numbers, such as with Kruskal's tree theorem and the Robertson–Seymour theorem.

## Computers and computational complexity

Between 1980 and 2000, hard disk sizes increased from about 10 megabytes (107 bytes) to over 100 gigabytes (1011 bytes).[citation needed] A 100 gigabyte disk could store the given names of all of Earth's seven billion inhabitants without using data compression.[citation needed] But what about a dictionary-on-disk storing all possible passwords containing up to 40 characters? Assuming each character equals one byte, there are about 2320 such passwords, which is about 2 × 1096. In his paper Computational capacity of the universe,[4] Seth Lloyd points out that if every particle in the universe could be used as part of a huge computer, it could store only about 1090 bits, less than one millionth of the size such a dictionary would require. However, storing information on hard disk and computing it are very different functions. On the one hand storage currently has limitations as stated, but computational speed is a different matter. It is quite conceivable[by whom?] that the stated limitations regarding storage have no bearing on the limitations of actual computational capacity,[citation needed] especially if the current research into quantum computers results in a "quantum leap" (but see holographic principle).

Still, computers can easily be programmed to start creating and displaying all possible 40-character passwords one at a time. Such a program could be left to run indefinitely. Assuming a modern PC could output 1 billion strings per second, it would take one billionth of 2 × 1096 seconds, or 2 × 1087 seconds to complete its task, which is about 6 × 1079 years. By contrast, the universe is estimated to be 13.8 billion (1.38 × 1010) years old. Computers will presumably continue to get faster, but the same paper mentioned before estimates that the entire universe functioning as a giant computer could have performed no more than 10120 operations since the Big Bang. This is trillions of times more computation than is required for displaying all 40-character passwords, but computing all 50 character passwords would outstrip the estimated computational potential of the entire universe.

Problems like this grow exponentially in the number of computations they require, and they are one reason why exponentially difficult problems are called "intractable" in computer science: for even small numbers like the 40 or 50 characters described earlier, the number of computations required exceeds even theoretical limits[citation needed] on mankind's computing power. The traditional division between "easy" and "hard" problems is thus drawn between programs that do and do not require exponentially increasing resources to execute.

Such limits are an advantage in cryptography, since any cipher-breaking technique that requires more than, say, the 10120 operations mentioned before will never be feasible. Such ciphers must be broken by finding efficient techniques unknown to the cipher's designer. Likewise, much of the research throughout all branches of computer science focuses on finding efficient solutions to problems that work with far fewer resources than are required by a naïve solution. For example, one way of finding the greatest common divisor between two 1000-digit numbers is to compute all their factors by trial division. This will take up to 2 × 10500 division operations, far too large to contemplate. But the Euclidean algorithm, using a much more efficient technique, takes only a fraction of a second to compute the GCD for even huge numbers such as these.

As a general rule, then, PCs in 2005 can perform 240 calculations in a few minutes.[citation needed] A few thousand PCs working for a few years could solve a problem requiring 264 calculations, but no amount of traditional computing power will solve a problem requiring 2128 operations (which is about what would be required to brute-force the encryption keys in 128-bit SSL commonly used in web browsers, assuming the underlying ciphers remain secure). Limits on computer storage are comparable.[quantify] Quantum computing may allow certain problems[vague] to become feasible, but it has practical and theoretical challenges that may never be overcome.[examples needed]

## Examples

• $10^{10}$ (10,000,000,000), called "ten billion" in the short scale or "ten milliard" in the long scale.
• googol = $10^{100}$ (10,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000).
• centillion = $10^{303}$ or $10^{600}$, depending on number naming system
• googolplex = $10^{\text{googol}}=10^{10^{100}}$
• Skewes' numbers: the first is approximately $10^{10^{10^{34}}}$, the second $10^{10^{10^{1000}}}$
• Graham's number = larger than can be represented here, even using power towers; however, it can be represented using Knuth's up-arrow notation.

The total amount of printed material in the world is roughly 1.6 × 1018 bits[citation needed]; therefore the contents can be represented by a number somewhere in the range 0 to roughly $2^{1.6 \times 10^{18}}\approx 10^{4.8 \times 10^{17}}$

Compare:

• $1.1^{1.1^{1.1^{1000}}} \approx 10^{10^{1.02\times10^{40}}}$
• $1000^{1000^{1000}}\approx 10^{10^{3000.48}}$

The first number is much larger than the second, due to the larger height of the power tower, and in spite of the small numbers 1.1. In comparing the magnitude of each successive exponent in the last number with $10^{10^{10}}$, we find a difference in the magnitude of effect on the final exponent.

## Systematically creating ever faster increasing sequences

Given a strictly increasing integer sequence/function $f_0(n)$ (n≥1) we can produce a faster growing sequence $f_1(n) = f_0^n(n)$ (where the superscript n denotes the nth functional power). This can be repeated any number of times by letting $f_k(n) = f_{k-1}^n(n)$, each sequence growing much faster than the one before it. Then we could define $f_\omega(n) = f_n(n)$, which grows much faster than any $f_k$ for finite k (here ω is the first infinite ordinal number, representing the limit of all finite numbers k). This is the basis for the fast-growing hierarchy of functions, in which the indexing subscript is extended to ever-larger ordinals.

For example, starting with f0(n) = n + 1:

• f1(n) = f0n(n) = n + n = 2n
• f2(n) = f1n(n) = 2nn > (2 ↑) n for n ≥ 2 (using Knuth up-arrow notation)
• f3(n) = f2n(n) > (2 ↑)n n ≥ 2 ↑2 n for n ≥ 2.
• fk+1(n) > 2 ↑k n for n ≥ 2, k < ω.
• fω(n) = fn(n) > 2 ↑n - 1 n > 2 ↑n − 2 (n + 3) − 3 = A(n, n) for n ≥ 2, where A is the Ackermann function (of which fω is a unary version).
• fω+1(64) > fω64(6) > Graham's number (= g64 in the sequence defined by g0 = 4, gk+1 = 3 ↑gk 3).
• This follows by noting fω(n) > 2 ↑n - 1 n > 3 ↑n - 2 3 + 2, and hence fω(gk + 2) > gk+1 + 2.
• fω(n) > 2 ↑n - 1 n = (2 → nn-1) = (2 → nn-1 → 1) (using Conway chained arrow notation)
• fω+1(n) = fωn(n) > (2 → nn-1 → 2) (because if gk(n) = X → nk then X → nk+1 = gkn(1))
• fω+k(n) > (2 → nn-1 → k+1) > (nnk)
• fω2(n) = fω+n(n) > (nnn) = (nnn→ 1)
• fω2+k(n) > (nnnk)
• fω3(n) > (nnnn)
• fωk(n) > (nn → ... → nn) (Chain of k+1 n's)
• fω2(n) = fωn(n) > (nn → ... → nn) (Chain of n+1 n's)

## Standardized system of writing very large numbers

A standardized way of writing very large numbers allows them to be easily sorted in increasing order, and one can get a good idea of how much larger a number is than another one.

To compare numbers in scientific notation, say 5×104 and 2×105, compare the exponents first, in this case 5 > 4, so 2×105 > 5×104. If the exponents are equal, the mantissa (or coefficient) should be compared, thus 5×104 > 2×104 because 5 > 2.

Tetration with base 10 gives the sequence $10 \uparrow \uparrow n=10 \to n \to 2=(10\uparrow)^n 1$, the power towers of numbers 10, where $(10\uparrow)^n$ denotes a functional power of the function $f(n)=10^n$ (the function also expressed by the suffix "-plex" as in googolplex, see the Googol family).

These are very round numbers, each representing an order of magnitude in a generalized sense. A crude way of specifying how large a number is, is specifying between which two numbers in this sequence it is.

More accurately, numbers in between can be expressed in the form $(10\uparrow)^n a$, i.e., with a power tower of 10s and a number at the top, possibly in scientific notation, e.g. $10^{10^{10^{10^{10^{4.829}}}}}$, a number between $10\uparrow\uparrow 5$ and $10\uparrow\uparrow 6$ (note that $10 \uparrow\uparrow n < (10\uparrow)^n a < 10 \uparrow\uparrow (n+1)$ if $1 < a < 10$). (See also extension of tetration to real heights.)

Thus googolplex is $10^{10^{100}} = (10\uparrow)^2 100 = (10\uparrow)^3 2$

Another example:

$2 \uparrow\uparrow\uparrow 4 = \begin{matrix} \underbrace{2_{}^{2^{{}^{.\,^{.\,^{.\,^2}}}}}}\\ \qquad\quad\ \ \ 65,536\mbox{ copies of }2 \end{matrix} \approx (10\uparrow)^{65,531}(6.0 \times 10^{19,728}) \approx (10\uparrow)^{65,533} 4.3$ (between $10\uparrow\uparrow 65,533$ and $10\uparrow\uparrow 65,534$)

Thus the "order of magnitude" of a number (on a larger scale than usually meant), can be characterized by the number of times (n) one has to take the $log_{10}$ to get a number between 1 and 10. Thus, the number is between $10\uparrow\uparrow n$ and $10\uparrow\uparrow (n+1)$. As explained, a more accurate description of a number also specifies the value of this number between 1 and 10, or the previous number (taking the logarithm one time less) between 10 and 1010, or the next, between 0 and 1.

Note that

$10^{(10\uparrow)^{n}x}=(10\uparrow)^{n}10^x$

I.e., if a number x is too large for a representation $(10\uparrow)^{n}x$ we can make the power tower one higher, replacing x by log10x, or find x from the lower-tower representation of the log10 of the whole number. If the power tower would contain one or more numbers different from 10, the two approaches would lead to different results, corresponding to the fact that extending the power tower with a 10 at the bottom is then not the same as extending it with a 10 at the top (but, of course, similar remarks apply if the whole power tower consists of copies of the same number, different from 10).

If the height of the tower is large, the various representations for large numbers can be applied to the height itself. If the height is given only approximately, giving a value at the top does not make sense, so we can use the double-arrow notation, e.g. $10\uparrow\uparrow(7.21\times 10^8)$. If the value after the double arrow is a very large number itself, the above can recursively be applied to that value.

Examples:

$10\uparrow\uparrow 10^{\,\!10^{10^{3.81\times 10^{17}}}}$ (between $10\uparrow\uparrow\uparrow 2$ and $10\uparrow\uparrow\uparrow 3$)
$10\uparrow\uparrow 10\uparrow\uparrow (10\uparrow)^{497}(9.73\times 10^{32})=(10\uparrow\uparrow)^{2} (10\uparrow)^{497}(9.73\times 10^{32})$ (between $10\uparrow\uparrow\uparrow 4$ and $10\uparrow\uparrow\uparrow 5$)

Similarly to the above, if the exponent of $(10\uparrow)$ is not exactly given then giving a value at the right does not make sense, and we can, instead of using the power notation of $(10\uparrow)$, add 1 to the exponent of $(10\uparrow\uparrow)$, so we get e.g. $(10\uparrow\uparrow)^{3} (2.8\times 10^{12})$.

If the exponent of $(10\uparrow \uparrow)$ is large, the various representations for large numbers can be applied to this exponent itself. If this exponent is not exactly given then, again, giving a value at the right does not make sense, and we can, instead of using the power notation of $(10\uparrow \uparrow)$, use the triple arrow operator, e.g. $10\uparrow\uparrow\uparrow(7.3\times 10^{6})$.

If the right-hand argument of the triple arrow operator is large the above applies to it, so we have e.g. $10\uparrow\uparrow\uparrow(10\uparrow\uparrow)^{2} (10\uparrow)^{497}(9.73\times 10^{32})$ (between $10\uparrow\uparrow\uparrow 10\uparrow\uparrow\uparrow 4$ and $10\uparrow\uparrow\uparrow 10\uparrow\uparrow\uparrow 5$). This can be done recursively, so we can have a power of the triple arrow operator.

We can proceed with operators with higher numbers of arrows, written $\uparrow^n$.

Compare this notation with the hyper operator and the Conway chained arrow notation:

$a\uparrow^n b$ = ( abn ) = hyper(an + 2, b)

An advantage of the first is that when considered as function of b, there is a natural notation for powers of this function (just like when writing out the n arrows): $(a\uparrow^n)^k b$. For example:

$(10\uparrow^2)^3 b$ = ( 10 → ( 10 → ( 10 → b → 2 ) → 2 ) → 2 )

and only in special cases the long nested chain notation is reduced; for b = 1 we get:

$10\uparrow^3 3 = (10\uparrow^2)^3 1$ = ( 10 → 3 → 3 )

Since the b can also be very large, in general we write a number with a sequence of powers $(10 \uparrow^n)^{k_n}$ with decreasing values of n (with exactly given integer exponents ${k_n}$) with at the end a number in ordinary scientific notation. Whenever a ${k_n}$ is too large to be given exactly, the value of ${k_{n+1}}$ is increased by 1 and everything to the right of $({n+1})^{k_{n+1}}$ is rewritten.

For describing numbers approximately, deviations from the decreasing order of values of n are not needed. For example, $10 \uparrow (10 \uparrow \uparrow)^5 a=(10 \uparrow \uparrow)^6 a$, and $10 \uparrow (10 \uparrow \uparrow \uparrow 3)=10 \uparrow \uparrow (10 \uparrow \uparrow 10 + 1)\approx 10 \uparrow \uparrow \uparrow 3$. Thus we have the somewhat counterintuitive result that a number x can be so large that, in a way, x and 10x are "almost equal" (for arithmetic of large numbers see also below).

If the superscript of the upward arrow is large, the various representations for large numbers can be applied to this superscript itself. If this superscript is not exactly given then there is no point in raising the operator to a particular power or to adjust the value on which it acts. We can simply use a standard value at the right, say 10, and the expression reduces to $10 \uparrow^n 10=(10 \to 10 \to n)$ with an approximate n. For such numbers the advantage of using the upward arrow notation no longer applies, and we can also use the chain notation.

The above can be applied recursively for this n, so we get the notation $\uparrow^n$ in the superscript of the first arrow, etc., or we have a nested chain notation, e.g.:

(10 → 10 → (10 → 10 → $3 \times 10^5$) ) = $10 \uparrow ^{10 \uparrow ^{3 \times 10^5} 10} 10 \!$

If the number of levels gets too large to be convenient, a notation is used where this number of levels is written down as a number (like using the superscript of the arrow instead of writing many arrows). Introducing a function $f(n)=10 \uparrow^{n} 10$ = (10 → 10 → n), these levels become functional powers of f, allowing us to write a number in the form $f^m(n)$ where m is given exactly and n is an integer which may or may not be given exactly (for the example: $f^2(3 \times 10^5)$. If n is large we can use any of the above for expressing it. The "roundest" of these numbers are those of the form fm(1) = (10→10→m→2). For example, $(10 \to 10 \to 3\to 2) = 10 \uparrow ^{10 \uparrow ^{10^{10}} 10} 10 \!$

Compare the definition of Graham's number: it uses numbers 3 instead of 10 and has 64 arrow levels and the number 4 at the top; thus $G < 3\rightarrow 3\rightarrow 65\rightarrow 2 <(10 \to 10 \to 65\to 2)=f^{65}(1)$, but also $G < f^{64}(4).

If m in $f^m(n)$ is too large to give exactly we can use a fixed n, e.g. n = 1, and apply the above recursively to m, i.e., the number of levels of upward arrows is itself represented in the superscripted upward-arrow notation, etc. Using the functional power notation of f this gives multiple levels of f. Introducing a function $g(n)=f^{n}(1)$ these levels become functional powers of g, allowing us to write a number in the form $g^m(n)$ where m is given exactly and n is an integer which may or may not be given exactly. We have (10→10→m→3) = gm(1). If n is large we can use any of the above for expressing it. Similarly we can introduce a function h, etc. If we need many such functions we can better number them instead of using a new letter every time, e.g. as a subscript, so we get numbers of the form $f_k^m(n)$ where k and m are given exactly and n is an integer which may or may not be given exactly. Using k=1 for the f above, k=2 for g, etc., we have (10→10→nk) = $f_k(n)=f_{k-1}^n(1)$. If n is large we can use any of the above for expressing it. Thus we get a nesting of forms ${f_k}^{m_k}$ where going inward the k decreases, and with as inner argument a sequence of powers $(10 \uparrow^n)^{p_n}$ with decreasing values of n (where all these numbers are exactly given integers) with at the end a number in ordinary scientific notation.

When k is too large to be given exactly, the number concerned can be expressed as ${f_n}(10)$=(10→10→10→n) with an approximate n. Note that the process of going from the sequence $10^{n}$=(10→n) to the sequence $10 \uparrow^n 10$=(10→10→n) is very similar to going from the latter to the sequence ${f_n}(10)$=(10→10→10→n): it is the general process of adding an element 10 to the chain in the chain notation; this process can be repeated again (see also the previous section). Numbering the subsequent versions of this function a number can be described using functions ${f_{qk}}^{m_{qk}}$, nested in lexicographical order with q the most significant number, but with decreasing order for q and for k; as inner argument we have a sequence of powers $(10 \uparrow^n)^{p_n}$ with decreasing values of n (where all these numbers are exactly given integers) with at the end a number in ordinary scientific notation.

For a number too large to write down in the Conway chained arrow notation we can describe how large it is by the length of that chain, for example only using elements 10 in the chain; in other words, we specify its position in the sequence 10, 10→10, 10→10→10, .. If even the position in the sequence is a large number we can apply the same techniques again for that.

### Examples of numbers in numerical order

Numbers expressible in decimal notation:

• 22 = 4
• 222 = 2 ↑↑ 3 = 16
• 33 = 27
• 44 = 256
• 55 = 3125
• 66 = 46,656
• $2^{2^{2^{2}}}$ = 2 ↑↑ 4 = 2↑↑↑3 = 65,536
• 77 = 823,543
• 106 = 1,000,000 = 1 million
• 88 = 16,777,216
• 99 = 387,420,489
• 109 = 1,000,000,000 = 1 billion
• 1010 = 10,000,000,000
• 1012 = 1,000,000,000,000 = 1 trillion
• 333 = 3 ↑↑ 3 = 7,625,597,484,987 ≈ 7.63 × 1012
• 1015 = 1,000,000,000,000,000 = 1 million billion = 1 quadrillion

Numbers expressible in scientific notation:

• Approximate number of atoms in the observable universe = 1080 = 100,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000
• googol = 10100 = 10,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000
• 444 = 4 ↑↑ 3 ≈ 1.34 × 10154 ≈ (10 ↑)2 2.2
• Approximate number of Planck volumes composing the volume of the observable universe = 8.5 × 10184
• 555 = 5 ↑↑ 3 ≈ 1.91 × 102184 ≈ (10 ↑)2 3.3
• $2^{2^{2^{2^2}}} = 2 \uparrow \uparrow 5 = 2^{65,536} \approx 2.0 \times 10^{19,728} \approx (10 \uparrow)^2 4.3$
• 666 = 6 ↑↑ 3 ≈ 2.66 × 1036,305 ≈ (10 ↑)2 4.6
• 777 = 7 ↑↑ 3 ≈ 3.76 × 10695,974 ≈ (10 ↑)2 5.8
• 888 = 8 ↑↑ 3 ≈ 6.01 × 1015,151,335 ≈ (10 ↑)2 7.2
• $M_{57,885,161} \approx 5.81 \times 10^{17,425,169} \approx 10^{10^{7.2}} = (10 \uparrow)^2 7.2$, the 48th and as of January 2013 the largest known Mersenne prime.
• 999 = 9 ↑↑ 3 ≈ 4.28 × 10369,693,099 ≈ (10 ↑)2 8.6
• 101010 =10 ↑↑ 3 = 1010,000,000,000 = (10 ↑)3 1
• $3^{3^{3^{3}}} = 3 \uparrow \uparrow 4 \approx 1.26 \times 10^{3,638,334,640,024} \approx (10 \uparrow)^3 1.10$

Numbers expressible in (10 ↑)n k notation:

• googolplex = $10^{10^{100}} = (10 \uparrow)^3 2$
• $2^{2^{2^{2^{2^2}}}} = 2 \uparrow \uparrow 6 = 2^{2^{65,536}} \approx 2^{(10 \uparrow)^2 4.3} \approx 10^{(10 \uparrow)^2 4.3} = (10 \uparrow)^3 4.3$
• $10^{10^{10^{10}}}=10 \uparrow \uparrow 4=(10 \uparrow)^4 1$
• $3^{3^{3^{3^3}}} = 3 \uparrow \uparrow 5 \approx 3^{10^{3.6 \times 10^{12}}} \approx (10 \uparrow)^4 1.10$
• $2^{2^{2^{2^{2^{2^2}}}}} = 2 \uparrow \uparrow 7 = \approx (10 \uparrow)^4 4.3$
• 10 ↑↑ 5 = (10 ↑)5 1
• 3 ↑↑ 6 ≈ (10 ↑)5 1.10
• 2 ↑↑ 8 ≈ (10 ↑)5 4.3
• 10 ↑↑ 6 = (10 ↑)6 1
• 10 ↑↑↑ 2 = 10 ↑↑ 10 = (10 ↑)10 1
• 2 ↑↑↑↑ 3 = 2 ↑↑↑ 4 = 2 ↑↑ 65,536 ≈ (10 ↑)65,533 4.3 is between 10 ↑↑ 65,533 and 10 ↑↑ 65,534

Bigger numbers:

• 3 ↑↑↑ 3 = 3 ↑↑ (3 ↑↑ 3) ≈ 3 ↑↑ 7.6 × 1012 ≈ 10 ↑↑ 7.6 × 1012 is between (10 ↑↑)2 2 and (10 ↑↑)2 3
• $10\uparrow\uparrow\uparrow 3=(10 \uparrow \uparrow)^3 1$ = ( 10 → 3 → 3 )
• $(10\uparrow\uparrow)^2 11$
• $(10\uparrow\uparrow)^2 10^{\,\!10^{10^{3.81\times 10^{17}}}}$
• $10\uparrow\uparrow\uparrow 4=(10 \uparrow \uparrow)^4 1$ = ( 10 → 4 → 3 )
• $(10\uparrow\uparrow)^{2} (10\uparrow)^{497}(9.73\times 10^{32})$
• $10\uparrow\uparrow\uparrow 5=(10 \uparrow \uparrow)^5 1$ = ( 10 → 5 → 3 )
• $10\uparrow\uparrow\uparrow 6=(10 \uparrow \uparrow)^6 1$ = ( 10 → 6 → 3 )
• $10\uparrow\uparrow\uparrow 7=(10 \uparrow \uparrow)^7 1$ = ( 10 → 7 → 3 )
• $10\uparrow\uparrow\uparrow 8=(10 \uparrow \uparrow)^8 1$ = ( 10 → 8 → 3 )
• $10\uparrow\uparrow\uparrow 9=(10 \uparrow \uparrow)^9 1$ = ( 10 → 9 → 3 )
• $10 \uparrow \uparrow \uparrow \uparrow 2 = 10\uparrow\uparrow\uparrow 10=(10 \uparrow \uparrow)^10 1$ = ( 10 → 2 → 4 ) = ( 10 → 10 → 3 )
• The first term in the definition of Graham's number, g1 = 3 ↑↑↑↑ 3 = 3 ↑↑↑ (3 ↑↑↑ 3) ≈ 3 ↑↑↑ (10 ↑↑ 7.6 × 1012) ≈ 10 ↑↑↑ (10 ↑↑ 7.6 × 1012) is between (10 ↑↑↑)2 2 and (10 ↑↑↑)2 3 (See Graham's number#Magnitude)
• $10\uparrow\uparrow\uparrow\uparrow 3=(10 \uparrow \uparrow\uparrow)^3 1$ = (10 → 3 → 4)
• $4 \uparrow \uparrow \uparrow \uparrow 4$ = ( 4 → 4 → 4 ) $\approx (10 \uparrow \uparrow \uparrow)^2 (10 \uparrow \uparrow)^3 154$
• $10\uparrow\uparrow\uparrow\uparrow 4=(10 \uparrow \uparrow\uparrow)^4 1$ = ( 10 → 4 → 4 )
• $10\uparrow\uparrow\uparrow\uparrow 5=(10 \uparrow \uparrow\uparrow)^5 1$ = ( 10 → 5 → 4 )
• $10\uparrow\uparrow\uparrow\uparrow 6=(10 \uparrow \uparrow\uparrow)^6 1$ = ( 10 → 6 → 4 )
• $10\uparrow\uparrow\uparrow\uparrow 7=(10 \uparrow \uparrow\uparrow)^7 1=$ = ( 10 → 7 → 4 )
• $10\uparrow\uparrow\uparrow\uparrow 8=(10 \uparrow \uparrow\uparrow)^8 1=$ = ( 10 → 8 → 4 )
• $10\uparrow\uparrow\uparrow\uparrow 9=(10 \uparrow \uparrow\uparrow)^9 1=$ = ( 10 → 9 → 4 )
• $10 \uparrow \uparrow \uparrow \uparrow \uparrow 2 = 10\uparrow\uparrow\uparrow\uparrow 10=(10 \uparrow \uparrow\uparrow)^{10} 1$ = ( 10 → 2 → 5 ) = ( 10 → 10 → 4 )
• ( 2 → 3 → 2 → 2 ) = ( 2 → 3 → 8 )
• ( 3 → 2 → 2 → 2 ) = ( 3 → 2 → 9 ) = ( 3 → 3 → 8 )
• ( 10 → 10 → 10 ) = ( 10 → 2 → 11 )
• ( 10 → 2 → 2 → 2 ) = ( 10 → 2 → 100 )
• ( 10 → 10 → 2 → 2 ) = ( 10 → 2 → $10^{10}$ ) = $10 \uparrow ^{10^{10}} 10 \!$
• The second term in the definition of Graham's number, g2 = 3 ↑g1 3 > 10 ↑g1 - 1 10.
• ( 10 → 10 → 3 → 2 ) = (10 → 10 → (10 → 10 → $10^{10}$) ) = $10 \uparrow ^{10 \uparrow ^{10^{10}} 10} 10 \!$
• g3 = (3 → 3 → g2) > (10 → 10 → g2 - 1) > (10 → 10 → 3 → 2)
• g4 = (3 → 3 → g3) > (10 → 10 → g3 - 1) > (10 → 10 → 4 → 2)
• ...
• g9 = (3 → 3 → g8) is between (10 → 10 → 9 → 2) and (10 → 10 → 10 → 2)
• ( 10 → 10 → 10 → 2 )
• g10 = (3 → 3 → g9) is between (10 → 10 → 10 → 2) and (10 → 10 → 11 → 2)
• ...
• g63 = (3 → 3 → g62) is between (10 → 10 → 63 → 2) and (10 → 10 → 64 → 2)
• ( 10 → 10 → 64 → 2 )
• Graham's number, g64[5]
• ( 10 → 10 → 65 → 2 )
• ( 10 → 10 → 10 → 3 )
• ( 10 → 10 → 10 → 4 )

## Comparison of base values

The following illustrates the effect of a base different from 10, base 100. It also illustrates representations of numbers, and the arithmetic.

$100^{12}=10^{24}$, with base 10 the exponent is doubled.

$100^{100^{12}}=10^{2*10^{24}}$, ditto.

$100^{100^{100^{12}}}=10^{10^{2*10^{24}+0.3}}$, the highest exponent is very little more than doubled.

• $100\uparrow\uparrow 2=10^ {200}$
• $100\uparrow\uparrow 3=10^ {2 \times 10^ {200}}$
• $100\uparrow\uparrow 4=(10\uparrow)^2 (2 \times 10^ {200}+0.3)=(10\uparrow)^2 (2\times 10^ {200})=(10\uparrow)^3 200.3=(10\uparrow)^4 2.3$
• $100\uparrow\uparrow n=(10\uparrow)^{n-2} (2 \times 10^ {200})=(10\uparrow)^{n-1} 200.3=(10\uparrow)^{n}2.3<10\uparrow\uparrow (n+1)$ (thus if n is large it seems fair to say that $100\uparrow\uparrow n$ is "approximately equal to" $10\uparrow\uparrow n$)
• $100\uparrow\uparrow\uparrow 2=(10\uparrow)^{98} (2 \times 10^ {200})=(10\uparrow)^{100} 2.3$
• $100\uparrow\uparrow\uparrow 3=10\uparrow\uparrow(10\uparrow)^{98} (2 \times 10^ {200})=10\uparrow\uparrow(10\uparrow)^{100} 2.3$
• $100\uparrow\uparrow\uparrow n=(10\uparrow\uparrow)^{n-2}(10\uparrow)^{98} (2 \times 10^ {200})=(10\uparrow\uparrow)^{n-2}(10\uparrow)^{100} 2.3<10\uparrow\uparrow\uparrow (n+1)$ (compare $10\uparrow\uparrow\uparrow n=(10\uparrow\uparrow)^{n-2}(10\uparrow)^{10}1<10\uparrow\uparrow\uparrow (n+1)$; thus if n is large it seems fair to say that $100\uparrow\uparrow\uparrow n$ is "approximately equal to" $10\uparrow\uparrow\uparrow n$)
• $100\uparrow\uparrow\uparrow\uparrow 2=(10\uparrow\uparrow)^{98}(10\uparrow)^{100} 2.3$ (compare $10\uparrow\uparrow\uparrow\uparrow 2=(10\uparrow\uparrow)^{8}(10\uparrow)^{10}1$)
• $100\uparrow\uparrow\uparrow\uparrow 3=10\uparrow\uparrow\uparrow(10\uparrow\uparrow)^{98}(10\uparrow)^{100} 2.3$ (compare $10\uparrow\uparrow\uparrow\uparrow 3=10\uparrow\uparrow\uparrow(10\uparrow\uparrow)^{8}(10\uparrow)^{10}1$)
• $100\uparrow\uparrow\uparrow\uparrow n=(10\uparrow\uparrow\uparrow)^{n-2}(10\uparrow\uparrow)^{98}(10\uparrow)^{100} 2.3$ (compare $10\uparrow\uparrow\uparrow\uparrow n=(10\uparrow\uparrow\uparrow)^{n-2}(10\uparrow\uparrow)^{8}(10\uparrow)^{10}1$; if n is large this is "approximately" equal)

## Accuracy

Note that for a number $10^n$, one unit change in n changes the result by a factor 10. In a number like $10^{\,\!6.2 \times 10^3}$, with the 6.2 the result of proper rounding using significant figures, the true value of the exponent may be 50 less or 50 more. Hence the result may be a factor $10^{50}$ too large or too small. This seems like extremely poor accuracy, but for such a large number it may be considered fair (a large error in a large number may be "relatively small" and therefore acceptable).

### Accuracy for very large numbers

In the case of an approximation of an extremely large number, the relative error may be large, yet there may still be a sense in which we want to consider the numbers as "close in magnitude". For example, consider

$10^{10}$ and $10^9$

The relative error is

$1 - \frac{10^9}{10^{10}} = 1 - \frac{1}{10} = 90\%$

a large relative error. However, we can also consider the relative error in the logarithms; in this case, the logarithms (to base 10) are 10 and 9, so the relative error in the logarithms is only 10%.

The point is that exponential functions magnify relative errors greatly – if a and b have a small relative error,

$10^a$ and $10^b$

the relative error is larger, and

$10^{10^a}$ and $10^{10^b}$

will have even larger relative error. The question then becomes: on which level of iterated logarithms do we wish to compare two numbers? There is a sense in which we may want to consider

$10^{10^{10}}$ and $10^{10^9}$

to be "close in magnitude". The relative error between these two numbers is large, and the relative error between their logarithms is still large; however, the relative error in their second-iterated logarithms is small:

$\log_{10}(\log_{10}(10^{10^{10}})) = 10$ and $\log_{10}(\log_{10}(10^{10^9})) = 9$

Such comparisons of iterated logarithms are common, e.g., in analytic number theory.

### Approximate arithmetic for very large numbers

There are some general rules relating to the usual arithmetic operations performed on very large numbers:

• The sum and the product of two very large numbers are both "approximately" equal to the larger one.
• $(10^a)^{\,\!10^b}=10^{a 10^b}=10^{10^{b+\log _{10} a}}$

Hence:

• A very large number raised to a very large power is "approximately" equal to the larger of the following two values: the first value and 10 to the power the second. For example, for very large n we have $n^n\approx 10^n$ (see e.g. the computation of mega) and also $2^n\approx 10^n$. Thus $2\uparrow\uparrow 65536 \approx 10\uparrow\uparrow 65533$, see table.

## Large numbers in some noncomputable sequences

The busy beaver function Σ is an example of a function which grows faster than any computable function. Its value for even relatively small input is huge. The values of Σ(n) for n = 1, 2, 3, 4 are 1, 4, 6, 13 (sequence A028444 in OEIS). Σ(5) is not known but is definitely ≥ 4098. Σ(6) is at least 3.5×1018267.

## Infinite numbers

Although all these numbers above are very large, they are all still decidedly finite. Certain fields of mathematics define infinite and transfinite numbers. For example, aleph-null is the cardinality of the infinite set of natural numbers, and aleph-one is the next greatest cardinal number. $\mathfrak{c}$ is the cardinality of the reals. The proposition that $\mathfrak{c} = \aleph_1$ is known as the continuum hypothesis.

## Notations

Some notations for extremely large numbers:

These notations are essentially functions of integer variables, which increase very rapidly with those integers. Ever faster increasing functions can easily be constructed recursively by applying these functions with large integers as argument.

Note that a function with a vertical asymptote is not helpful in defining a very large number, although the function increases very rapidly: one has to define an argument very close to the asymptote, i.e. use a very small number, and constructing that is equivalent to constructing a very large number, e.g. the reciprocal.

5. ^ Regarding the comparison with the previous value: $10\uparrow ^n 10 < 3 \uparrow ^{n+1} 3$, so starting the 64 steps with 1 instead of 4 more than compensates for replacing the numbers 3 by 10


text:
# Classical truss element explained

## Learn how to derive the truss element stiffness matrix from kinematic assumptions. And discover how it compares to Abaqus T3D2 element.

When talking about structural finite elements, the truss element is one of the first elements discussed. As long as the assumptions underlying its usage are met, it is an efficient element allowing convenient interpretation of results. I will discuss here theses assumptions as well as the truss element use cases. Then I will showcase the element formulation, leading to the expression for the stiffness matrix, as it is implemented in SesamX. Finally, I will discuss the SesamX data cards that are used to define the truss element and compare the results with the Abaqus T3D2 element on a simple model.

## Quick remark on notations

Before starting, let’s define some notations that are used through this article:

• vectors are denoted with an underline $\underline{u}$ ,

• matrices are represented with brackets $\lbrack \ \rbrack$ ,

• Einstein summation convention is used on repeated indices,

• partial derivatives are denoted with the comma notation $u_{,x}$ ,

• infinitesimal strain and stress tensors are represented in column matrix notation $\lbrack \epsilon \rbrack = \begin{bmatrix} \epsilon_{11} \\ \epsilon_{22} \\ \epsilon_{33} \\ \epsilon_{12} \\ \epsilon_{23} \\ \epsilon_{13} \end{bmatrix}$ and $\lbrack \sigma \rbrack = \begin{bmatrix} \sigma_{11} \\ \sigma_{22} \\ \sigma_{33} \\ \sigma_{12} \\ \sigma_{23} \\ \sigma_{13} \end{bmatrix}$ , where $\lbrack \epsilon \rbrack$ represents the engineering strains.

## Introduction

This element is relevant to use when we aim at analysing a slender structure which only undergoes axial loading.

For such a structure, the axial stress assumption is commonly used:

$$\sigma_{22} = \sigma_{33} = \sigma_{12} = \sigma_{23} = \sigma_{13} = 0 \tag{1}$$

$$u_{i,y} = u_{i,z} = 0 \tag{2}$$

(1) is also called the stress assumption and (2) the kinematic assumption. These assumptions are considered valid for cross-section typical dimension less than 110 of the truss length.

Stresses that are orthogonal to the truss axis are considered null as well as the dependence of the displacement on $y$ and $z$ . Thus, knowing the displacement on the truss axis is enough to describe the displacement over the whole structure: the truss element is a 1-dimensional element.

As it will appear during the stiffness matrix derivation, the relevant geometric parameters of the truss are:

• the length of the truss $L$ ,

• and the area of the truss section $A$ .

In its more simple formulation (presented here), it consists of 2 nodes connected together through a segment, yielding a linear displacement interpolation inside the element.

Assembling trusses is useful to modelize bars connected to each other by mean of pin joints, like in a crane or a bridge.

## Truss element derivation

As mentioned previously, we can represent the truss element as shown in the following figure, along with its local basis vectors.

The element local axis system is defined by the axis $x, y, z$ whose basis vectors are respectively denoted as $\underline{e_{1}}, \underline{e_{2}}, \underline{e_{3}}$ .

Only the translational degrees of freedom are required on each node of the element. Hence, the displacement on node $I$ will be denoted $\underline{u^I} = {u_j}^I \underline{e_{j}}$ , where $I$ takes the values 1 or 2.

### Strain tensor

Using assumption (2) the displacement inside the element can be written:

$$\underline{u} = \begin{cases} u_1(x) \\ u_2(x) \\ u_3(x) \end{cases}$$

However, the only known information is at the node. To get the displacement inside the element we interpolate linearly the nodes displacements as follows:

$${u_j}(x_1) = N^I(x) {u_j}^I \tag{3}$$

Where the $N^I$ represent the shape functions of the element:

$$\begin{cases} N^1(x) = 1 - \cfrac{x}{L} \\ N^2(x) = \cfrac{x}{L} \end{cases}$$

Next, we simply compute the strains by differentiation:

$$\lbrack \epsilon \rbrack = \begin{bmatrix} \epsilon_{11} \\ \epsilon_{22} \\ \epsilon_{33} \\ \epsilon_{12} \\ \epsilon_{23} \\ \epsilon_{13} \end{bmatrix} = \begin{bmatrix} u_{1,x} \\ 0 \\ 0 \\ u_{2,x} \\ 0 \\ u_{3,x} \end{bmatrix}$$

However, we want the truss element to be sensitive only to axial strain. We can simply enforce other strains to be 0. Physically this means that even if there are some $u_2$ and $u_3$ displacements in the element, they do not contribute to the strain state of the element. Hence, we have:

$$\lbrack \epsilon \rbrack = \begin{bmatrix} \epsilon_{11} \\ \epsilon_{22} \\ \epsilon_{33} \\ \epsilon_{12} \\ \epsilon_{23} \\ \epsilon_{13} \end{bmatrix} = \begin{bmatrix} u_{1,x} \\ 0 \\ 0 \\ 0 \\ 0 \\ 0 \end{bmatrix}$$

Finally, using (3) we get the strains in the element from the displacements at
the nodes:

$$\lbrack \epsilon \rbrack = \begin{bmatrix} N^I_{,x} {u_1}^I \\ 0 \\ 0 \\ 0 \\ 0 \\ 0 \end{bmatrix} \tag{4}$$

### Stress tensor

To relate the stresses to the strains we need to apply Hooke’s law for linear elastic material.

$$\begin{bmatrix} \epsilon_{11} \\ \epsilon_{22} \\ \epsilon_{33} \\ \epsilon_{12} \\ \epsilon_{23} \\ \epsilon_{13} \end{bmatrix} = \frac{1}{E} \begin{bmatrix} 1 && -\nu && -\nu && 0 && 0 && 0 \\ -\nu && 1 && -\nu && 0 && 0 && 0 \\ -\nu && -\nu && 1 && 0 && 0 && 0 \\ 0 && 0 && 0 && 2+2\nu && 0 && 0 \\ 0 && 0 && 0 && 0 && 2+2\nu && 0 \\ 0 && 0 && 0 && 0 && 0 && 2+2\nu \end{bmatrix} \begin{bmatrix} \sigma_{11} \\ \sigma_{22} \\ \sigma_{33} \\ \sigma_{12} \\ \sigma_{23} \\ \sigma_{13} \end{bmatrix} \\$$

Using assumption (1) on the right hand side, as well as the result we got in (4) on the left hand side, leads to a peculiar relation:

$$\underbrace{ \begin{bmatrix} u_{1,x} \\ 0 \\ 0 \\ 0 \\ 0 \\ 0 \end{bmatrix} }_{\text{kinematic assumption}} = \underbrace{ \frac{1}{E} \begin{bmatrix} \sigma_{11} \\ -\nu\sigma_{11} \\ -\nu\sigma_{11} \\ 0 \\ 0 \\ 0 \end{bmatrix} }_{\text{stress assumption}}$$

Which obviously cannot hold. However this inconsistency is not that dramatic: when making the kinematic assumption we were interested in the macroscopic behavior of the truss. Whereas the stress assumption relates more to a microscopic behavior. It turns out that even if $\epsilon_{22}$ and $\epsilon_{33}$ are not 0 (microscopic scale) their effect on the displacement (macroscopic scale) is negligible compare to what comes from the $\epsilon_{11}$ term. Of course, this explanation becomes questionable as the slenderness of the truss degrades.

We can then simplify this relation and write:

$$\begin{bmatrix} u_{1,x} \\ 0 \\ 0 \\ 0 \\ 0 \\ 0 \end{bmatrix} = \frac{1}{E} \begin{bmatrix} \sigma_{11} \\ 0 \\ 0 \\ 0 \\ 0 \\ 0 \end{bmatrix}$$

Finally, using (4) we have the stress from the displacement at the nodes:

$$\sigma_{11} = E N^I_{,x} {u_1}^I$$

## Element stiffness derivation

The element stiffness matrix is obtained through the expression of the virtual work. Denoting the virtual strains as $\lbrack \overline{\epsilon} \rbrack$ we have for the virtual work over the element volume:

$$\overline{W} = \iiint_V \lbrack \overline{\epsilon} \rbrack^T \lbrack \sigma \rbrack dV = \iiint_V (N^I_{,x} \overline{{u_1}^I}) (E N^J_{,x} {u_1}^J) dV$$

The integrand depends only on $x$ , thus we can integrate along $y$ and $z$ to get:

$$\overline{W} = EA \int_L \overline{{u_1}^I} N^I_{,x} N^J_{,x} {u_1}^J dx$$

Using the previous definition of the shape functions, the stiffness matrix is therefore:

$$\boxed{ \lbrack K \rbrack = \frac{EA}{L} \begin{bmatrix} 1 & -1 \\ -1 & 1 \end{bmatrix} }$$

## SesamX input cards

To define a truss element in SesamX the first step is to create a mesh. This is done with the CREATE-SUBMESH function:

CREATE-SUBMESH
MODEL: TRUSS_SIMPLE
NODES
- ID: 1  POINT: 0.,0.,0.
- ID: 2  POINT: 10.,0.,0.
- ID: 3  POINT: 20.,0.,0.
ELEMENTS
SHAPE: LN2
-ID: 1  NODES: 1,2
-ID: 1  NODES: 2,3

Here we define 3 nodes and we create 2 line elements to connect the nodes. The next step is to apply the truss property on these 2 elements.

CREATE-PROPERTIES
MODEL: TRUSS_SIMPLE
TRUSS-STANDARD
BEHAVIOR: LINEAR
NAME: PROP1
AREA: 40.0
MATERIAL: STEEL
ON-ELEMENTS-FROM: SELE_ALL

Here we apply a TRUSS-STANDARD property on the elements from ALL_TRUSS providing a material name STEEL (that we defined previously, not shown here) and an area. BEHAVIOR: LINEAR indicates that we apply a linear elastic material. This keyword may seem unnecessary at the moment, but it is a provision for future material implementations (such as hyper-elastic materials).

## Comparison with Abaqus T3D2 element

Eventually, the last part of this article focuses on the comparison of SesamX linear truss element against Abaqus equivalent T3D2 element. A truss assembly clamped on one end is subjected to a load on the second end. The displacements at the nodes, obtained from a linear static resolution, are compared between SesamX and Abaqus.

### Model

The model studied for this comparison is made of a the following truss assembly.

As you can see on the picture, nodes are located at trusses intersections. Each truss is $1 m$ long and has an area of $40 mm^2$ . A linear elastic material is applied with $E = 200 GPa$ and $\nu = 0.33$ . The far left nodes are clamped while a downward load of $1000 N$ is applied on the bottom right node.

This case is then solved with a linear static resolution.

### Results

The following figure gives an overview of the expected displacement of the model, as well as the node numbers.

And the table below gives the comparison of the nodal displacements between Abaqus and SesamX.

The relative error on the magnitude is quite small, SesamX linear truss element implementation is very close to Abaqus implementation.

Following these links you have access to the SesamX input cards as well as the Abaqus input cards that I used for this comparison. I imported the Abaqus mesh and selections in SesamX (to make sure I have the same model description) and then I defined the properties, loads and boundary conditions.