The two quotient rings are coordinate rings of affine varieties.

The tensor product of coordinate rings is the coordinate ring of the product variety (under some assumptions).

You can construct it like this:

```
R.<x0,x1> = PolynomialRing(QQ)
IR = R.ideal(x0^2-x1^3)
QR = R.quotient(IR)
S.<y0,y1,y2> = PolynomialRing(QQ)
JS = S.ideal(y0*y1-y2^2)
QS = S.quotient(JS)
T.<a0,a1,b0,b1,b2> = PolynomialRing(QQ)
R_to_T = R.hom([a0,a1])
S_to_T = S.hom([b0,b1,b2])
IT = R_to_T(IR)
JT = S_to_T(JS)
QT = T.quotient(IT + JT)
QR_to_QT = QR.hom(map(QT,[a0,a1]))
QS_to_QT = QS.hom(map(QT,[b0,b1,b2]))
```

The object you want is `QT`

, which is a quotient of the polynomial ring `T`

.

There are maps from `R`

and `S`

to `T`

, and induced maps from `QR`

and `QS`

to `QT`

.

I used different names for the generators in `R`

and `S`

, but you can also use the same ones as you did, or e.g.:

```
R = PolynomialRing(QQ, 'x', 2)
IR = R.ideal(R.0^2-R.1^3)
QR = R.quotient(IR)
S = PolynomialRing(QQ, 'x', 3)
JS = S.ideal(S.0*S.1-S.2^2)
QS = S.quotient(JS)
T = PolynomialRing(QQ, 'z', R.ngens() + S.ngens())
R_to_T = R.hom(T.gens()[0:R.ngens()])
S_to_T = S.hom(T.gens()[R.ngens():R.ngens() + S.ngens()])
IT = R_to_T(IR)
JT = S_to_T(JS)
QT = T.quotient(IT + JT)
QR_to_QT = QR.hom([QT(R_to_T(g)) for g in R.gens()])
QS_to_QT = QS.hom([QT(S_to_T(g)) for g in S.gens()])
```

Here `R.0`

is shorthand for `R.gen(0)`

, the first generator of `R`

, namely `x0`

; `R.ngens()`

is the number of generators of `R`

; `R.gens()`

is the list of generators of `R`

, etc.