## dg.differential geometry – Lie transformation group and transformation of a smooth structure from a normally connected subgroup

I myself am working on two theorems on the Lie transformation group from the book Kobayashi Transformation Group in Differential Geometry

sentence To let $$mathfrak {S}$$ the group of the differentiable transformation of the manifold $$M$$ and $$mathcal {S}$$ Let be the set of all vector fields $$X in mathfrak {X} (M)$$ this creates 1 parameter subgroup $$varphi_ {t} = text {exp} (tX)$$
the transformation for $$M$$ so that $$varphi_ {t} in mathfrak {S}$$, The sentence $$mathcal {S}$$ Use parentheses of the vector field to define a Lie algebra. Then, when $$mathcal {S}$$ is the finite-dimensional Lie algebra of vector fields $$M$$ then $$mathfrak {S}$$ Lie group of transformation and $$mathcal {S}$$ his lie algebra.

The idea of ​​the proof is quite simple, take the Lie algebra $$mathfrak {g} ^ {*}$$ generated by $$mathcal {S}$$, if $$mathfrak {g} ^ {*}$$ if finite-dimensional, then according to the third set of Lie, there are simply connected Lie-groups $$mathfrak {S} ^ {*}$$ the last can be chosen so that $$mathfrak {S} ^ {*} subset mathfrak {S}$$ Using local action etc … more can be shown that it is a normally connected subgroup and is open. At the moment, everything seems normal, but then the author claims that the smooth structure can be converted into another connected component or simply agrees $$mathfrak {S}$$ if I'm not mistaken, I can not get it here, unless we accept the left translation or the right one for $$g in mathfrak {S}$$, the assignment $$L_ {g}: mathfrak {S} ^ {*} longrightarrow g. Mathfrak {S} ^ {*}$$ be differentiable.

My question is about the idea of ​​how we transfer smooth structure from connected normal subgroups?

There is an essay by Richard S.Plais. A global formulation of the lie theory of transformation groups contains a lot of things about it, but I could not see exactly where the answer is.

## Why should you lift the nose of the structure? Fix all the disadvantages of Cape – everything else

What is a nose lift? What does Li do when he has to? Ask for instructions, software, rewards, rewards and rewards Software, software, rewards and rewards

Hardware, Hardware, Rectangle, Rectangle, Rectangle

See more:

The method is only a part of them. Hardware, hardware, hardware and hardware. Time, when you are inside, when you are inside

Hence software and software, software and software and software. Goods are not different

4. Electric shock with length:

One of the games together. If nothing, it is difficult.

,

## Java Database Structure – Code Review Stack Exchange

In order to stay in practice with good Java programming techniques, I have decided to write a database. It stores only employees, allows logged in users to retrieve / hire employees, and has a sign-in mechanism that prevents the use of methods when you are not logged in. I'm looking for feedback in the following areas:

• structure Is the overall structure of the program good? Are there any improvements that can make the structure of the program more efficient / compact?
• Login mechanism Is the way I implemented this system alright? Is there a better way to implement this login system?
• exceptions I have created two custom exceptions for this program. Is the way I coded these exceptions acceptable? Should I have had one? `Custom exception` Class from which they could inherit so that I can only have the message `print error message` as parameter / hard coded? I use `darkness` when writing these exceptions, so that the `serialVersionUID` is generated automatically.
• Efficiency / compactness Is there a way to make this program more efficient? Just like that `getHighestSalary` Method in the Database class.

All suggestions are asked and appreciated. Style and other cleanliness tips are also recommended.

Database.java

``````Package database;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Database {

private ArrayList employees;
private boolean logged in;

public database () {

this.employees = new ArrayList();
this.loggedIn = false;

populateEmployees ();
}

if (logged in) {
sortEmployees ();
Return;
}
trigger new LoginException ("Not logged in!");
}

public Employee getHighestSalary () triggers LoginException {
if (logged in) {
Employee highest = this.employees.get (0);
for (Employee Employee: this.employees) {
if (employee.getSalary ()> highest.getSalary ()) {
highest = employee;
}
}
return the highest;
}
trigger new LoginException ("Not logged in!");
}

@SuppressWarnings ("deactivated")
public void sortEmployees () triggers LoginException {
if (logged in) {
Collections.sort ((List) this.employees);
Return;
}
trigger new LoginException ("Not logged in!");
}

public Employee getEmployee (String name) triggers EmployeeNotFoundException, LoginException {
if (logged in) {
for (Employee Employee: this.employees) {
if (employee.getName (). equals (name)) {
Return employee;
}
}
}
trigger new LoginException ("Not logged in!");
}

// filler for tester class
private void populateEmployees () {
for (int i = 0; i <10; i ++) {
this.employees.add (new employee ("Employee" + i));
}
}

this.loggedIn = true;
}
}

public ArrayList getEmployees () triggers LoginException {
if (logged in) {
Give this back.
}
trigger new LoginException ("Not logged in!");
}

// used for testing
}

// used for testing
}

}
``````

Employee.java

``````Package database;

public class employee {

private final string name;
private int age;
private int salary;

public employee (String name) {
this.name = name;
}

public employee (string name, int age) {
this.name = name;
this.age = age;
}

Public employee (string name, int. Age, int. Salary) {
this.name = name;
this.age = age;
this.salary = salary;
}

public String getName () {return this.name; }
public int getAge () {return this.age; }
public int getSalary () {return this.salary; }

public String toString () {
return "name:" + this.name;
}

}
``````

``````Package database;

public class LoginException extends Exception {

private static final long serialVersionUID = 1L;

great (message);
}

public void printErrorMessage () {
}

}
``````

EmployeeNotFoundException.java

``````Package database;

public class EmployeeNotFoundException extends Exception {

private static final long serialVersionUID = 1L;

public EmployeeNotFoundException (String message) {
great (message);
}

public void printErrorMessage () {
}

}
``````

Tester.java

``````Package database;

public class testers {

@SuppressWarnings ("unused")
public static void main (String[] Arguments) {
Database database = new Database ();

To attempt {
for (employee employees: database.getEmployees ()) {
System.out.println (employee);
}
e.printErrorMessage ();
}

// Should `EmployeeNotFoundException` trigger
To attempt {
Employee test = database.getEmployee ("Ben");
} catch (EmployeeNotFoundException e) {
e.printErrorMessage ();
e.printErrorMessage ();
}

}

}
``````

## PHP – What would be the access to this jquery data structure?

I want to display this data structure from Jquery, but I can not, I leave some of the code, if I do the query with postman, I see all the content, but when I try to display with jquery, only headers are displayed.

``````        {
"DOC": [
{
"Doc": 2,
"Est": "P2"
},
{
"Doc": 4,
"Est": "P3"
}
].
"ID": [
{
"Car": 1,
"Est": "P3"
}
].
"TOTAL": 7
}

Success: Function (Result) {
var document = result.DOC;

for (var i in documento) {
var d = document[i].doc;
var e = document[i].est;
console.log (d);
console.log (e);
}
``````

## Calculate a shortest path in a table structure that changes in real time

I have a table that looks like this

In the NPC table, AI-like characters move from one point to another. Player – a character controlled by the user.

At any moment, the player character can move into any cell of the table. But NPC has a specific target cell to reach as they move. For example, the blue NPC must read the blue cell.

Other NPCs are moving as well. My goal is to write an algorithm that allows NPC to reach the cell by the shortest path. As far as I know, this is a typical problem with the shortest route.

My question is: Is there an algorithm specifically optimized for such workflows, or are enough algorithms to recalculate the path after each move?

## postgresql – plpgsql: mismatched brackets at or near ";" in nested loop structure

I wrote a do-block to store only the tables in a Postgres database, but when I ran the script I got this error message. I can not see where parentheses do not match. I added the captions after seeing this error for the first time, but the error could not be fixed.

``````psql \$ DBNAME << EOF
DO  \$\$
TO EXPLAIN
Myschema RECORD;
myview RECORD;
myfunc RECORD;
myseq RECORD;
BEGIN

FOR myschema IN (SELECT schema_name FROM information_schema.schemata;)
<>
LOOP

- Delete all views
FOR myview IN (SELECT viewname FROM pg_catalog.pg_views WHERE schema_name = myschema.schema_name;)
<>
LOOP
& # 39; DROP VIEW & # 39; EXECUTE || quote_ident (mychema.myview.viewname) || & # 39 & # 39 ;; ;;
END LOOP foreachview;

- Drop all functions
FOR myfunc IN (SELECT routine-name FROM information-schema.routines WHERE routine_type = & # 39; FUNCTION & # 39; AND specific_schema = & # 39; public & # 39 ;;)
<>
LOOP
& # 39; DROP FUNCTION & # 39; EXECUTE || quote_ident (mychema.myfunc.routine_name) || & # 39 & # 39 ;; ;;
END LOOP foreachfunc;

- Delete all sequences
FOR myseq IN (SELECT sequencename FROM informationschema.sequences;)
<>
LOOP
& # 39; DROP SEQUENCE & # 39; EXECUTE || quote_ident (mychema.myseq.sequence_name) || & # 39 & # 39 ;; ;;
END LOOP foreachseq;

END LOOP foreachschema;

THE END;
\$\$ LANGUAGE plpgsql;
EOF
``````
``````ERROR: Mismatching brackets at or near ";"
LINE 9: ... ma IN (SELECT schema_name FROM information_schema.schemata;)
``````

Final work code:

``````psql \$ DBNAME << EOF
DO  \$\$
TO EXPLAIN
Myschema RECORD;
myview RECORD;
myfunc RECORD;
myseq RECORD;
BEGIN

FOR myschema IN (SELECT schema_name FROM information_schema.schemata WHERE schema_name NOT LIKE & # 39; pg_% & # 39; AND schema_name <> & # 39; information_schema & # 39;
LOOP

- Delete all views
FOR myview IN (SELECT viewname FROM pg_catalog.pg_views WHERE schema_name = myschema.schema_name)
LOOP
& # 39; DROP VIEW & # 39; EXECUTE || quote_ident (myschema.schema_name) || . & # 39; & # 39; || quote_ident (myview.viewname) || & # 39 & # 39 ;; ;;
END LOOP;

- Drop all functions
FOR myfunc IN (SELECT routine-name FROM information-schema.routines WHERE routine_type = & # 39; FUNCTION & # 39; AND specific_schema = & # 39; public & # 39;
LOOP
& # 39; DROP VIEW & # 39; EXECUTE || quote_ident (myschema.schema_name) || . & # 39; & # 39; || quote_ident (myfunc.routine_name) || & # 39 & # 39 ;; ;;
END LOOP;

- Delete all sequences
FOR myseq IN (SELECT sequencename FROM informationsschema.sequences)
LOOP
& # 39; DROP VIEW & # 39; EXECUTE || quote_ident (myschema.schema_name) || . & # 39; & # 39; || quote_ident (myseq.sequence_name) || & # 39 & # 39 ;; ;;
END LOOP;

END LOOP;

THE END;
\$\$ LANGUAGE plpgsql;
EOF
``````

## Category Theory – Which Structure Preserve Natural Isomorphisms?

My understanding from model theory is that for the groups A and B the statement applies $$A cong B$$ implies that any for any first order statement $$P$$ in the language of the groups, $$P (A) iff P (B)$$,

Can an analogous statement be made for the naturally isomorphic functors F and G? Ie is it true that $$F cong G implies P (F) iff P (G)$$ for a collection of suggestions about functors?

I have been told that isomorphisms are the "right" notion of algebraic equivalence because they "preserve structure," and I am very much concerned with why natural isomorphisms are the "right" notion of functor equivalency.

I have seen explanations like:

Set functions $$X times C rightarrow D$$ can be identified with functions $$X rightarrow D ^ C$$, Morphisms in a category $$X$$ can be identified with functors $$2 rightarrow X$$So morphisms in the functor category $$D ^ C$$ should be identified with functors $$2 rightarrow D ^ C$$, But in analogy to set functions, $$2 rightarrow D ^ C$$ & # 39; equal & # 39; $$2 times C rightarrow D$$ from which the definition of natural transformations can be derived.

The above explanation intuitively refers to a fundamental property of set functions and products, but does not superficially tell me what is true / is specific to isomorphic functors.

The definition of natural transformation is enforced if we prescribe it $$Cat$$ be Cartesian closed, but again I do not understand the relationship to the preservation of the & # 39; structure & # 39 ;.

I have seen references to the "principle of equivalence"
which seems to support the notion that isomorphic objects should be indistinguishable in one language.

From ncatlab:

Michael Makkai proposed the principle of isomorphism: "All
grammatically correct properties of objects of a fixed category are to be considered
be invariant under isomorphism "

How does the definition of natural isomorphisms make this statement true in the category? $$D ^ C$$ With functors as objects and morphisms as natural transformations? What is invariant? If natural transformations represent a "change of perspective" analogous to conjugation, what remains between the perspectives?

Can someone give a formalization of the ideas behind the answers here?

I'm really stuck here.

## How do I structure an append-only database in PostgreSQL?

### foreword

We have been stuck in a monolithic program with a terrible and inefficient database structure for years. Now we finally move away with our own program.

The only area we are having trouble with is the database. Our data is financial and our existing program causes data loss, mainly by overwriting (`TO UPDATE`. `CLEAR`). We chose a pure append structure to get all the data we collected. We may consider using a warehouse as it grows beyond our initial estimates. In the meantime, however, we expect the database for some of the larger tables to grow to a few million lines in a few years. not massive at this point.

We use PostgreSQL and deny change rights like `TO UPDATE` and `CLEAR` for users to ensure the historical consistency of the data.

### Our ideas

We thought we could put all the necessary data in a table so that we query the last (or newest) record `time stamp`) for each `I would` as indicated in the following table.

``````╔═════╦════╦════════╦════════╦════════════════════ ═╗
║ key ║ ID ║ field1 ║ field2 ║ time stamp ║
╠═════╬════╬════════╬════════╬════════════════════ ═╣
║ 0 ║ 0 ║ a ║ b ║ 1970-01-01 00:00:01 ║
╠═════╬════╬════════╬════════╬════════════════════ ═╣
║ 1 ║ 1 ║ x ║ y ║ 1970-01-01 00:00:02 ║
╠═════╬════╬════════╬════════╬════════════════════ ═╣
║ 2 ║ 0 ║ a ║ c ║ 1970-01-01 00:05:01 ║ # new version of id = 0 row
╚═════╩════╩════════╩════════╩════════════════════ ═╝
``````

We also considered NoSQL solutions, with the exception that we prefer to remain ACID compliant (and most NoSQL solutions can not meet this expectation).

We also looked at other products like AWS QLDB, but are budget-dependent. Therefore, we decided to use PostgreSQL for the time being and will re-evaluate it if necessary.

1. How can we best structure the database to ensure optimal performance, but also consider developer usage and usability?
2. Does our existing idea of ​​structuring the database provide optimal performance and is it coherent?
3. What limitations and problems (other than disk space) can we create for ourselves with this plan?

## What is the best URL structure for a travel blog?

I have a travel blog where I write about things to do in different cities around the world.

The URL of these pages is currently as follows: Site / Country / Country name. There are several cities listed in each country.

• First, I'd like to know if it would be better to reorganize the site and have these URLs like site / country name. Does that really help search engine optimization?

• Then I wonder if it's better to have long pages with multiple cities in it, or divide them into multiple city pages, each with less content, and create URLs like this page / country name / city name

## google search – Can I use BreadcrumbList Structured Data on my website if no breadcrumb trail appears on the page or in my URL structure?

I've read that breadcrumbs help Google better understand the structure of your site, so I want to implement it on mine. However, I currently have no breadcrumb trail visible on the site. Does this not agree with the best practices for having the markup but not visually displaying it to the user?

Also, my URL structure does not contain breadcrumbs. On article pages, the URL looks like this: https://example.com/article-slug/, and on subcategory pages, the top level category does not appear: For example, I use https://example.com/camping -gear / instead of https://example.com/outdoors/camping-gear.

Can I continue to implement BreadcrumbList despite these two factors?