url stringclasses 147
values | commit stringclasses 147
values | file_path stringlengths 7 101 | full_name stringlengths 1 94 | start stringlengths 6 10 | end stringlengths 6 11 | tactic stringlengths 1 11.2k | state_before stringlengths 3 2.09M | state_after stringlengths 6 2.09M | input stringlengths 73 2.09M |
|---|---|---|---|---|---|---|---|---|---|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.not_isLower_toUpper | [97, 1] | [107, 15] | absurd h'.1 | c : ASCII.Char
h : 97 ≤ c.toNat ∧ c.toNat ≤ 122
h' : 97 ≤ c.toNat - 32 ∧ c.toNat - 32 ≤ 122
⊢ False | c : ASCII.Char
h : 97 ≤ c.toNat ∧ c.toNat ≤ 122
h' : 97 ≤ c.toNat - 32 ∧ c.toNat - 32 ≤ 122
⊢ ¬97 ≤ c.toNat - 32 | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
h : 97 ≤ c.toNat ∧ c.toNat ≤ 122
h' : 97 ≤ c.toNat - 32 ∧ c.toNat - 32 ≤ 122
⊢ False
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.not_isLower_toUpper | [97, 1] | [107, 15] | apply Nat.not_le_of_gt | c : ASCII.Char
h : 97 ≤ c.toNat ∧ c.toNat ≤ 122
h' : 97 ≤ c.toNat - 32 ∧ c.toNat - 32 ≤ 122
⊢ ¬97 ≤ c.toNat - 32 | case h
c : ASCII.Char
h : 97 ≤ c.toNat ∧ c.toNat ≤ 122
h' : 97 ≤ c.toNat - 32 ∧ c.toNat - 32 ≤ 122
⊢ 97 > c.toNat - 32 | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
h : 97 ≤ c.toNat ∧ c.toNat ≤ 122
h' : 97 ≤ c.toNat - 32 ∧ c.toNat - 32 ≤ 122
⊢ ¬97 ≤ c.toNat - 32
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.not_isLower_toUpper | [97, 1] | [107, 15] | apply Nat.lt_of_le_of_lt (Nat.sub_le_sub_right h.2 32) | case h
c : ASCII.Char
h : 97 ≤ c.toNat ∧ c.toNat ≤ 122
h' : 97 ≤ c.toNat - 32 ∧ c.toNat - 32 ≤ 122
⊢ 97 > c.toNat - 32 | case h
c : ASCII.Char
h : 97 ≤ c.toNat ∧ c.toNat ≤ 122
h' : 97 ≤ c.toNat - 32 ∧ c.toNat - 32 ≤ 122
⊢ 122 - 32 < 97 | Please generate a tactic in lean4 to solve the state.
STATE:
case h
c : ASCII.Char
h : 97 ≤ c.toNat ∧ c.toNat ≤ 122
h' : 97 ≤ c.toNat - 32 ∧ c.toNat - 32 ≤ 122
⊢ 97 > c.toNat - 32
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.not_isLower_toUpper | [97, 1] | [107, 15] | decide | case h
c : ASCII.Char
h : 97 ≤ c.toNat ∧ c.toNat ≤ 122
h' : 97 ≤ c.toNat - 32 ∧ c.toNat - 32 ≤ 122
⊢ 122 - 32 < 97 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
c : ASCII.Char
h : 97 ≤ c.toNat ∧ c.toNat ≤ 122
h' : 97 ≤ c.toNat - 32 ∧ c.toNat - 32 ≤ 122
⊢ 122 - 32 < 97
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.not_isLower_toUpper | [97, 1] | [107, 15] | assumption | case isFalse
c : ASCII.Char
h✝ : ¬(97 ≤ c.toNat ∧ c.toNat ≤ 122)
⊢ ¬(97 ≤ c.toNat ∧ c.toNat ≤ 122) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case isFalse
c : ASCII.Char
h✝ : ¬(97 ≤ c.toNat ∧ c.toNat ≤ 122)
⊢ ¬(97 ≤ c.toNat ∧ c.toNat ≤ 122)
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toUpper_eq_self_of_not_isLower | [109, 1] | [110, 39] | simp [toUpper] | c : ASCII.Char
h : ¬c.isLower = true
⊢ c.toUpper = c | c : ASCII.Char
h : ¬c.isLower = true
⊢ ∀ (h : c.isLower = true), ofNatAux (c.toNat - 32) ⋯ = c | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
h : ¬c.isLower = true
⊢ c.toUpper = c
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toUpper_eq_self_of_not_isLower | [109, 1] | [110, 39] | intro | c : ASCII.Char
h : ¬c.isLower = true
⊢ ∀ (h : c.isLower = true), ofNatAux (c.toNat - 32) ⋯ = c | c : ASCII.Char
h : ¬c.isLower = true
h✝ : c.isLower = true
⊢ ofNatAux (c.toNat - 32) ⋯ = c | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
h : ¬c.isLower = true
⊢ ∀ (h : c.isLower = true), ofNatAux (c.toNat - 32) ⋯ = c
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toUpper_eq_self_of_not_isLower | [109, 1] | [110, 39] | contradiction | c : ASCII.Char
h : ¬c.isLower = true
h✝ : c.isLower = true
⊢ ofNatAux (c.toNat - 32) ⋯ = c | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
h : ¬c.isLower = true
h✝ : c.isLower = true
⊢ ofNatAux (c.toNat - 32) ⋯ = c
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toLower_eq_self_of_not_isUpper | [112, 1] | [113, 39] | simp [toLower] | c : ASCII.Char
h : ¬c.isUpper = true
⊢ c.toLower = c | c : ASCII.Char
h : ¬c.isUpper = true
⊢ ∀ (h : c.isUpper = true), ofNatAux (c.toNat + 32) ⋯ = c | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
h : ¬c.isUpper = true
⊢ c.toLower = c
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toLower_eq_self_of_not_isUpper | [112, 1] | [113, 39] | intro | c : ASCII.Char
h : ¬c.isUpper = true
⊢ ∀ (h : c.isUpper = true), ofNatAux (c.toNat + 32) ⋯ = c | c : ASCII.Char
h : ¬c.isUpper = true
h✝ : c.isUpper = true
⊢ ofNatAux (c.toNat + 32) ⋯ = c | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
h : ¬c.isUpper = true
⊢ ∀ (h : c.isUpper = true), ofNatAux (c.toNat + 32) ⋯ = c
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toLower_eq_self_of_not_isUpper | [112, 1] | [113, 39] | contradiction | c : ASCII.Char
h : ¬c.isUpper = true
h✝ : c.isUpper = true
⊢ ofNatAux (c.toNat + 32) ⋯ = c | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
h : ¬c.isUpper = true
h✝ : c.isUpper = true
⊢ ofNatAux (c.toNat + 32) ⋯ = c
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.String.length_push | [148, 9] | [150, 16] | simp [length] | s : ASCII.String
c : ASCII.Char
⊢ (s.push c).length = s.length + 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
s : ASCII.String
c : ASCII.Char
⊢ (s.push c).length = s.length + 1
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.String.length_append | [152, 1] | [153, 39] | simp [length, ByteArray.size_append] | s t : ASCII.String
⊢ (s ++ t).length = s.length + t.length | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
s t : ASCII.String
⊢ (s ++ t).length = s.length + t.length
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.String.length_extract | [155, 1] | [157, 40] | simp [length, ByteArray.size_extract] | s : ASCII.String
start stop : Nat
⊢ (s.extract start stop).length = min stop s.length - start | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
s : ASCII.String
start stop : Nat
⊢ (s.extract start stop).length = min stop s.length - start
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.String.append_nil | [161, 9] | [162, 12] | ext | s : ASCII.String
⊢ s ++ "".toASCII ⋯ = s | case a.a
s : ASCII.String
⊢ (s ++ "".toASCII ⋯).toByteArray.data = s.toByteArray.data | Please generate a tactic in lean4 to solve the state.
STATE:
s : ASCII.String
⊢ s ++ "".toASCII ⋯ = s
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.String.append_nil | [161, 9] | [162, 12] | simp | case a.a
s : ASCII.String
⊢ (s ++ "".toASCII ⋯).toByteArray.data = s.toByteArray.data | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.a
s : ASCII.String
⊢ (s ++ "".toASCII ⋯).toByteArray.data = s.toByteArray.data
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.String.nil_append | [164, 9] | [165, 12] | ext | t : ASCII.String
⊢ "".toASCII ⋯ ++ t = t | case a.a
t : ASCII.String
⊢ ("".toASCII ⋯ ++ t).toByteArray.data = t.toByteArray.data | Please generate a tactic in lean4 to solve the state.
STATE:
t : ASCII.String
⊢ "".toASCII ⋯ ++ t = t
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.String.nil_append | [164, 9] | [165, 12] | simp | case a.a
t : ASCII.String
⊢ ("".toASCII ⋯ ++ t).toByteArray.data = t.toByteArray.data | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.a
t : ASCII.String
⊢ ("".toASCII ⋯ ++ t).toByteArray.data = t.toByteArray.data
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.String.append_assoc | [167, 1] | [168, 33] | ext | s t u : ASCII.String
⊢ s ++ t ++ u = s ++ (t ++ u) | case a.a
s t u : ASCII.String
⊢ (s ++ t ++ u).toByteArray.data = (s ++ (t ++ u)).toByteArray.data | Please generate a tactic in lean4 to solve the state.
STATE:
s t u : ASCII.String
⊢ s ++ t ++ u = s ++ (t ++ u)
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.String.append_assoc | [167, 1] | [168, 33] | simp [Array.append_assoc] | case a.a
s t u : ASCII.String
⊢ (s ++ t ++ u).toByteArray.data = (s ++ (t ++ u)).toByteArray.data | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.a
s t u : ASCII.String
⊢ (s ++ t ++ u).toByteArray.data = (s ++ (t ++ u)).toByteArray.data
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.String.append_push | [170, 1] | [171, 65] | ext | s t : ASCII.String
c : ASCII.Char
⊢ s ++ t.push c = (s ++ t).push c | case a.a
s t : ASCII.String
c : ASCII.Char
⊢ (s ++ t.push c).toByteArray.data = ((s ++ t).push c).toByteArray.data | Please generate a tactic in lean4 to solve the state.
STATE:
s t : ASCII.String
c : ASCII.Char
⊢ s ++ t.push c = (s ++ t).push c
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.String.append_push | [170, 1] | [171, 65] | simp [Array.push_eq_append_singleton, Array.append_assoc] | case a.a
s t : ASCII.String
c : ASCII.Char
⊢ (s ++ t.push c).toByteArray.data = ((s ++ t).push c).toByteArray.data | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.a
s t : ASCII.String
c : ASCII.Char
⊢ (s ++ t.push c).toByteArray.data = ((s ++ t).push c).toByteArray.data
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.String.get_push_lt | [178, 1] | [181, 39] | ext | s : ASCII.String
c : ASCII.Char
i : Nat
h : i < s.length
h' : optParam (i < (s.push c).length) ⋯
⊢ (s.push c)[i] = s[i] | case a.a
s : ASCII.String
c : ASCII.Char
i : Nat
h : i < s.length
h' : optParam (i < (s.push c).length) ⋯
⊢ (s.push c)[i].toByte.toNat = s[i].toByte.toNat | Please generate a tactic in lean4 to solve the state.
STATE:
s : ASCII.String
c : ASCII.Char
i : Nat
h : i < s.length
h' : optParam (i < (s.push c).length) ⋯
⊢ (s.push c)[i] = s[i]
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.String.get_push_lt | [178, 1] | [181, 39] | simp [ByteArray.get_push_lt, h] | case a.a
s : ASCII.String
c : ASCII.Char
i : Nat
h : i < s.length
h' : optParam (i < (s.push c).length) ⋯
⊢ (s.push c)[i].toByte.toNat = s[i].toByte.toNat | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.a
s : ASCII.String
c : ASCII.Char
i : Nat
h : i < s.length
h' : optParam (i < (s.push c).length) ⋯
⊢ (s.push c)[i].toByte.toNat = s[i].toByte.toNat
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.String.get_push_eq | [183, 1] | [184, 12] | ext | s : ASCII.String
c : ASCII.Char
⊢ (s.push c)[s.length] = c | case a.a
s : ASCII.String
c : ASCII.Char
⊢ (s.push c)[s.length].toByte.toNat = c.toByte.toNat | Please generate a tactic in lean4 to solve the state.
STATE:
s : ASCII.String
c : ASCII.Char
⊢ (s.push c)[s.length] = c
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.String.get_push_eq | [183, 1] | [184, 12] | simp | case a.a
s : ASCII.String
c : ASCII.Char
⊢ (s.push c)[s.length].toByte.toNat = c.toByte.toNat | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.a
s : ASCII.String
c : ASCII.Char
⊢ (s.push c)[s.length].toByte.toNat = c.toByte.toNat
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.String.get_append_left | [186, 1] | [189, 44] | ext | s t : ASCII.String
i : Nat
hlt : i < s.length
h : optParam (i < (s ++ t).length) ⋯
⊢ (s ++ t)[i] = s[i] | case a.a
s t : ASCII.String
i : Nat
hlt : i < s.length
h : optParam (i < (s ++ t).length) ⋯
⊢ (s ++ t)[i].toByte.toNat = s[i].toByte.toNat | Please generate a tactic in lean4 to solve the state.
STATE:
s t : ASCII.String
i : Nat
hlt : i < s.length
h : optParam (i < (s ++ t).length) ⋯
⊢ (s ++ t)[i] = s[i]
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.String.get_append_left | [186, 1] | [189, 44] | simp [ByteArray.get_append_left hlt] | case a.a
s t : ASCII.String
i : Nat
hlt : i < s.length
h : optParam (i < (s ++ t).length) ⋯
⊢ (s ++ t)[i].toByte.toNat = s[i].toByte.toNat | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.a
s t : ASCII.String
i : Nat
hlt : i < s.length
h : optParam (i < (s ++ t).length) ⋯
⊢ (s ++ t)[i].toByte.toNat = s[i].toByte.toNat
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.String.get_append_right | [191, 1] | [194, 53] | ext | s t : ASCII.String
i : Nat
hle : s.length ≤ i
h : i < (s ++ t).length
h' : optParam (i - s.length < t.length) ⋯
⊢ (s ++ t)[i] = t[i - s.length] | case a.a
s t : ASCII.String
i : Nat
hle : s.length ≤ i
h : i < (s ++ t).length
h' : optParam (i - s.length < t.length) ⋯
⊢ (s ++ t)[i].toByte.toNat = t[i - s.length].toByte.toNat | Please generate a tactic in lean4 to solve the state.
STATE:
s t : ASCII.String
i : Nat
hle : s.length ≤ i
h : i < (s ++ t).length
h' : optParam (i - s.length < t.length) ⋯
⊢ (s ++ t)[i] = t[i - s.length]
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.String.get_append_right | [191, 1] | [194, 53] | simp [length, ByteArray.get_append_right hle] | case a.a
s t : ASCII.String
i : Nat
hle : s.length ≤ i
h : i < (s ++ t).length
h' : optParam (i - s.length < t.length) ⋯
⊢ (s ++ t)[i].toByte.toNat = t[i - s.length].toByte.toNat | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.a
s t : ASCII.String
i : Nat
hle : s.length ≤ i
h : i < (s ++ t).length
h' : optParam (i - s.length < t.length) ⋯
⊢ (s ++ t)[i].toByte.toNat = t[i - s.length].toByte.toNat
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.String.get_extract | [196, 1] | [199, 12] | ext | i : Nat
s : ASCII.String
start stop : Nat
h : i < (s.extract start stop).length
h' : optParam (start + i < s.length) ⋯
⊢ (s.extract start stop)[i] = s[start + i] | case a.a
i : Nat
s : ASCII.String
start stop : Nat
h : i < (s.extract start stop).length
h' : optParam (start + i < s.length) ⋯
⊢ (s.extract start stop)[i].toByte.toNat = s[start + i].toByte.toNat | Please generate a tactic in lean4 to solve the state.
STATE:
i : Nat
s : ASCII.String
start stop : Nat
h : i < (s.extract start stop).length
h' : optParam (start + i < s.length) ⋯
⊢ (s.extract start stop)[i] = s[start + i]
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.String.get_extract | [196, 1] | [199, 12] | simp | case a.a
i : Nat
s : ASCII.String
start stop : Nat
h : i < (s.extract start stop).length
h' : optParam (start + i < s.length) ⋯
⊢ (s.extract start stop)[i].toByte.toNat = s[start + i].toByte.toNat | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.a
i : Nat
s : ASCII.String
start stop : Nat
h : i < (s.extract start stop).length
h' : optParam (start + i < s.length) ⋯
⊢ (s.extract start stop)[i].toByte.toNat = s[start + i].toByte.toNat
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Char.lean | ASCII.Char.toUnicode_isASCII | [51, 1] | [52, 72] | simp [Char.toUnicode, Char.isASCII, _root_.Char.toNat] | c : ASCII.Char
⊢ Char.isASCII ↑c = true | c : ASCII.Char
⊢ c.toByte.toNat < 128 | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
⊢ Char.isASCII ↑c = true
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Char.lean | ASCII.Char.toUnicode_isASCII | [51, 1] | [52, 72] | exact c.valid | c : ASCII.Char
⊢ c.toByte.toNat < 128 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
⊢ c.toByte.toNat < 128
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | refine' ⟨hr, hs, ht, hu, _⟩ | r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
rstu : r / s = t / u
⊢ proportion r s t u | r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
rstu : r / s = t / u
⊢ ∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t) | Please generate a tactic in lean4 to solve the state.
STATE:
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
rstu : r / s = t / u
⊢ proportion r s t u
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | intro n m | r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
rstu : r / s = t / u
⊢ ∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t) | r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
rstu : r / s = t / u
n m : ℕ
⊢ (↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t) | Please generate a tactic in lean4 to solve the state.
STATE:
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
rstu : r / s = t / u
⊢ ∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | field_simp at rstu | r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
rstu : r / s = t / u
n m : ℕ
⊢ (↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t) | r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
⊢ (↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t) | Please generate a tactic in lean4 to solve the state.
STATE:
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
rstu : r / s = t / u
n m : ℕ
⊢ (↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | constructor | r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
⊢ (↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t) | case left
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
⊢ ↑n * r = ↑m * s → ↑n * t = ↑m * u
case right
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
⊢ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t) | Please generate a tactic in lean4 to solve the state.
STATE:
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
⊢ (↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | intro h | case left
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
⊢ ↑n * r = ↑m * s → ↑n * t = ↑m * u | case left
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r = ↑m * s
⊢ ↑n * t = ↑m * u | Please generate a tactic in lean4 to solve the state.
STATE:
case left
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
⊢ ↑n * r = ↑m * s → ↑n * t = ↑m * u
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | suffices hh : (n : ℝ) * t * s = m * u * s | case left
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r = ↑m * s
⊢ ↑n * t = ↑m * u | case left
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r = ↑m * s
hh : ↑n * t * s = ↑m * u * s
⊢ ↑n * t = ↑m * u
case hh
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r = ↑m * s
⊢ ↑n * t * s = ↑m * u * s | Please generate a tactic in lean4 to solve the state.
STATE:
case left
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r = ↑m * s
⊢ ↑n * t = ↑m * u
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | convert (congr_arg (fun x => x / s) hh) using 1 | case left
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r = ↑m * s
hh : ↑n * t * s = ↑m * u * s
⊢ ↑n * t = ↑m * u | case h.e'_2
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r = ↑m * s
hh : ↑n * t * s = ↑m * u * s
⊢ ↑n * t = ↑n * t * s / s
case h.e'_3
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r = ↑m * s
hh : ↑n * t * s = ↑m * u * s
⊢ ↑m * u = ↑m * u * s / s | Please generate a tactic in lean4 to solve the state.
STATE:
case left
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r = ↑m * s
hh : ↑n * t * s = ↑m * u * s
⊢ ↑n * t = ↑m * u
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | all_goals field_simp | case h.e'_2
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r = ↑m * s
hh : ↑n * t * s = ↑m * u * s
⊢ ↑n * t = ↑n * t * s / s
case h.e'_3
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r = ↑m * s
hh : ↑n * t * s = ↑m * u * s
⊢ ↑m * u = ↑m * u * s / s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_2
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r = ↑m * s
hh : ↑n * t * s = ↑m * u * s
⊢ ↑n * t = ↑n * t * s / s
case h.e'_3
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r = ↑m * s
hh : ↑n * t * s = ↑m * u * s
⊢ ↑m * u = ↑m * u * s / s
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | field_simp | case h.e'_3
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r = ↑m * s
hh : ↑n * t * s = ↑m * u * s
⊢ ↑m * u = ↑m * u * s / s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r = ↑m * s
hh : ↑n * t * s = ↑m * u * s
⊢ ↑m * u = ↑m * u * s / s
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | convert (congr_arg (fun x => x * u) h) using 1 | case hh
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r = ↑m * s
⊢ ↑n * t * s = ↑m * u * s | case h.e'_2
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r = ↑m * s
⊢ ↑n * t * s = ↑n * r * u
case h.e'_3
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r = ↑m * s
⊢ ↑m * u * s = ↑m * s * u | Please generate a tactic in lean4 to solve the state.
STATE:
case hh
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r = ↑m * s
⊢ ↑n * t * s = ↑m * u * s
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | rw [mul_assoc, ← rstu] | case h.e'_2
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r = ↑m * s
⊢ ↑n * t * s = ↑n * r * u | case h.e'_2
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r = ↑m * s
⊢ ↑n * (r * u) = ↑n * r * u | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_2
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r = ↑m * s
⊢ ↑n * t * s = ↑n * r * u
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | ring | case h.e'_2
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r = ↑m * s
⊢ ↑n * (r * u) = ↑n * r * u | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_2
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r = ↑m * s
⊢ ↑n * (r * u) = ↑n * r * u
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | ring | case h.e'_3
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r = ↑m * s
⊢ ↑m * u * s = ↑m * s * u | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r = ↑m * s
⊢ ↑m * u * s = ↑m * s * u
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | constructor | case right
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
⊢ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t) | case right.left
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
⊢ ↑n * r < ↑m * s → ↑n * t < ↑m * u
case right.right
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
⊢ ↑m * s < ↑n * r → ↑m * u < ↑n * t | Please generate a tactic in lean4 to solve the state.
STATE:
case right
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
⊢ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | intro h | case right.left
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
⊢ ↑n * r < ↑m * s → ↑n * t < ↑m * u | case right.left
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r < ↑m * s
⊢ ↑n * t < ↑m * u | Please generate a tactic in lean4 to solve the state.
STATE:
case right.left
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
⊢ ↑n * r < ↑m * s → ↑n * t < ↑m * u
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | suffices hh : (n : ℝ) * t * s < m * u * s | case right.left
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r < ↑m * s
⊢ ↑n * t < ↑m * u | case right.left
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r < ↑m * s
hh : ↑n * t * s < ↑m * u * s
⊢ ↑n * t < ↑m * u
case hh
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r < ↑m * s
⊢ ↑n * t * s < ↑m * u * s | Please generate a tactic in lean4 to solve the state.
STATE:
case right.left
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r < ↑m * s
⊢ ↑n * t < ↑m * u
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | convert mul_lt_mul hh (by simp : (1:ℝ)/s ≤ 1/s) (by positivity) (by positivity) using 1 | case right.left
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r < ↑m * s
hh : ↑n * t * s < ↑m * u * s
⊢ ↑n * t < ↑m * u | case h.e'_3
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r < ↑m * s
hh : ↑n * t * s < ↑m * u * s
⊢ ↑n * t = ↑n * t * s * (1 / s)
case h.e'_4
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r < ↑m * s
hh : ↑n * t * s < ↑m * u * s
⊢ ↑m * u = ↑m * u * s * (1 / s) | Please generate a tactic in lean4 to solve the state.
STATE:
case right.left
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r < ↑m * s
hh : ↑n * t * s < ↑m * u * s
⊢ ↑n * t < ↑m * u
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | all_goals field_simp | case h.e'_3
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r < ↑m * s
hh : ↑n * t * s < ↑m * u * s
⊢ ↑n * t = ↑n * t * s * (1 / s)
case h.e'_4
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r < ↑m * s
hh : ↑n * t * s < ↑m * u * s
⊢ ↑m * u = ↑m * u * s * (1 / s) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r < ↑m * s
hh : ↑n * t * s < ↑m * u * s
⊢ ↑n * t = ↑n * t * s * (1 / s)
case h.e'_4
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r < ↑m * s
hh : ↑n * t * s < ↑m * u * s
⊢ ↑m * u = ↑m * u * s * (1 / s)
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | simp | r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r < ↑m * s
hh : ↑n * t * s < ↑m * u * s
⊢ 1 / s ≤ 1 / s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r < ↑m * s
hh : ↑n * t * s < ↑m * u * s
⊢ 1 / s ≤ 1 / s
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | positivity | r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r < ↑m * s
hh : ↑n * t * s < ↑m * u * s
⊢ 0 < 1 / s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r < ↑m * s
hh : ↑n * t * s < ↑m * u * s
⊢ 0 < 1 / s
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | positivity | r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r < ↑m * s
hh : ↑n * t * s < ↑m * u * s
⊢ 0 ≤ ↑m * u * s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r < ↑m * s
hh : ↑n * t * s < ↑m * u * s
⊢ 0 ≤ ↑m * u * s
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | field_simp | case h.e'_4
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r < ↑m * s
hh : ↑n * t * s < ↑m * u * s
⊢ ↑m * u = ↑m * u * s * (1 / s) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_4
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r < ↑m * s
hh : ↑n * t * s < ↑m * u * s
⊢ ↑m * u = ↑m * u * s * (1 / s)
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | rw [mul_assoc, ← rstu, ← mul_assoc] | case hh
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r < ↑m * s
⊢ ↑n * t * s < ↑m * u * s | case hh
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r < ↑m * s
⊢ ↑n * r * u < ↑m * u * s | Please generate a tactic in lean4 to solve the state.
STATE:
case hh
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r < ↑m * s
⊢ ↑n * t * s < ↑m * u * s
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | convert mul_lt_mul h (by simp : u ≤ u) (by positivity) (by positivity) using 1 | case hh
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r < ↑m * s
⊢ ↑n * r * u < ↑m * u * s | case h.e'_4
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r < ↑m * s
⊢ ↑m * u * s = ↑m * s * u | Please generate a tactic in lean4 to solve the state.
STATE:
case hh
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r < ↑m * s
⊢ ↑n * r * u < ↑m * u * s
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | ring | case h.e'_4
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r < ↑m * s
⊢ ↑m * u * s = ↑m * s * u | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_4
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r < ↑m * s
⊢ ↑m * u * s = ↑m * s * u
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | simp | r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r < ↑m * s
⊢ u ≤ u | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r < ↑m * s
⊢ u ≤ u
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | positivity | r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r < ↑m * s
⊢ 0 < u | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r < ↑m * s
⊢ 0 < u
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | positivity | r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r < ↑m * s
⊢ 0 ≤ ↑m * s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑n * r < ↑m * s
⊢ 0 ≤ ↑m * s
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | intros h | case right.right
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
⊢ ↑m * s < ↑n * r → ↑m * u < ↑n * t | case right.right
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
⊢ ↑m * u < ↑n * t | Please generate a tactic in lean4 to solve the state.
STATE:
case right.right
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
⊢ ↑m * s < ↑n * r → ↑m * u < ↑n * t
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | suffices hh : (m : ℝ) * u * s < n * t * s | case right.right
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
⊢ ↑m * u < ↑n * t | case right.right
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
hh : ↑m * u * s < ↑n * t * s
⊢ ↑m * u < ↑n * t
case hh
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
⊢ ↑m * u * s < ↑n * t * s | Please generate a tactic in lean4 to solve the state.
STATE:
case right.right
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
⊢ ↑m * u < ↑n * t
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | convert mul_lt_mul hh (by simp : (1:ℝ)/s ≤ 1/s) (by positivity) (by positivity) using 1 | case right.right
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
hh : ↑m * u * s < ↑n * t * s
⊢ ↑m * u < ↑n * t | case h.e'_3
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
hh : ↑m * u * s < ↑n * t * s
⊢ ↑m * u = ↑m * u * s * (1 / s)
case h.e'_4
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
hh : ↑m * u * s < ↑n * t * s
⊢ ↑n * t = ↑n * t * s * (1 / s) | Please generate a tactic in lean4 to solve the state.
STATE:
case right.right
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
hh : ↑m * u * s < ↑n * t * s
⊢ ↑m * u < ↑n * t
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | all_goals field_simp | case h.e'_3
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
hh : ↑m * u * s < ↑n * t * s
⊢ ↑m * u = ↑m * u * s * (1 / s)
case h.e'_4
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
hh : ↑m * u * s < ↑n * t * s
⊢ ↑n * t = ↑n * t * s * (1 / s) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
hh : ↑m * u * s < ↑n * t * s
⊢ ↑m * u = ↑m * u * s * (1 / s)
case h.e'_4
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
hh : ↑m * u * s < ↑n * t * s
⊢ ↑n * t = ↑n * t * s * (1 / s)
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | simp | r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
hh : ↑m * u * s < ↑n * t * s
⊢ 1 / s ≤ 1 / s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
hh : ↑m * u * s < ↑n * t * s
⊢ 1 / s ≤ 1 / s
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | positivity | r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
hh : ↑m * u * s < ↑n * t * s
⊢ 0 < 1 / s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
hh : ↑m * u * s < ↑n * t * s
⊢ 0 < 1 / s
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | positivity | r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
hh : ↑m * u * s < ↑n * t * s
⊢ 0 ≤ ↑n * t * s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
hh : ↑m * u * s < ↑n * t * s
⊢ 0 ≤ ↑n * t * s
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | field_simp | case h.e'_4
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
hh : ↑m * u * s < ↑n * t * s
⊢ ↑n * t = ↑n * t * s * (1 / s) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_4
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
hh : ↑m * u * s < ↑n * t * s
⊢ ↑n * t = ↑n * t * s * (1 / s)
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | rw [(by ring : (n : ℝ) * t * s = n * (t * s)), ← rstu] | case hh
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
⊢ ↑m * u * s < ↑n * t * s | case hh
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
⊢ ↑m * u * s < ↑n * (r * u) | Please generate a tactic in lean4 to solve the state.
STATE:
case hh
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
⊢ ↑m * u * s < ↑n * t * s
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | convert mul_lt_mul h (by simp : u ≤ u) (by positivity) (by positivity) using 1 | case hh
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
⊢ ↑m * u * s < ↑n * (r * u) | case h.e'_3
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
⊢ ↑m * u * s = ↑m * s * u
case h.e'_4
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
⊢ ↑n * (r * u) = ↑n * r * u | Please generate a tactic in lean4 to solve the state.
STATE:
case hh
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
⊢ ↑m * u * s < ↑n * (r * u)
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | all_goals ring | case h.e'_3
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
⊢ ↑m * u * s = ↑m * s * u
case h.e'_4
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
⊢ ↑n * (r * u) = ↑n * r * u | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
⊢ ↑m * u * s = ↑m * s * u
case h.e'_4
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
⊢ ↑n * (r * u) = ↑n * r * u
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | ring | r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
⊢ ↑n * t * s = ↑n * (t * s) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
⊢ ↑n * t * s = ↑n * (t * s)
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | simp | r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
⊢ u ≤ u | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
⊢ u ≤ u
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | positivity | r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
⊢ 0 < u | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
⊢ 0 < u
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | positivity | r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
⊢ 0 ≤ ↑n * r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
⊢ 0 ≤ ↑n * r
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | proportion_of_eq_ratio | [10, 1] | [32, 23] | ring | case h.e'_4
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
⊢ ↑n * (r * u) = ↑n * r * u | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_4
r s t u : ℝ
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
s_ne : s ≠ 0
u_ne : u ≠ 0
n m : ℕ
rstu : r * u = t * s
h : ↑m * s < ↑n * r
⊢ ↑n * (r * u) = ↑n * r * u
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | eq_ratio_of_proportion | [34, 1] | [91, 13] | obtain ⟨ hr, hs, ht, hu, h⟩ := h | r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
h : proportion r s t u
⊢ r / s = t / u | case intro.intro.intro.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
⊢ r / s = t / u | Please generate a tactic in lean4 to solve the state.
STATE:
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
h : proportion r s t u
⊢ r / s = t / u
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | eq_ratio_of_proportion | [34, 1] | [91, 13] | by_contra hh | case intro.intro.intro.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
⊢ r / s = t / u | case intro.intro.intro.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : ¬r / s = t / u
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
⊢ r / s = t / u
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | eq_ratio_of_proportion | [34, 1] | [91, 13] | change r / s ≠ t / u at hh | case intro.intro.intro.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : ¬r / s = t / u
⊢ False | case intro.intro.intro.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : ¬r / s = t / u
⊢ False
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | eq_ratio_of_proportion | [34, 1] | [91, 13] | by_cases rstu : r / s < t / u | case intro.intro.intro.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
⊢ False | case pos
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
⊢ False
case neg
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : ¬r / s < t / u
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
⊢ False
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | eq_ratio_of_proportion | [34, 1] | [91, 13] | have : ∃ n m : ℕ, r / s < n / m ∧ (n:ℝ) / m < t / u ∧ n ≠ 0 ∧ m ≠ 0 | case pos
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
⊢ False | case this
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
⊢ ∃ n m, r / s < ↑n / ↑m ∧ ↑n / ↑m < t / u ∧ n ≠ 0 ∧ m ≠ 0
case pos
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
this : ∃ n m, r / s < ↑n / ↑m ∧ ↑n / ↑m < t / u ∧ n ≠ 0 ∧ m ≠ 0
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
⊢ False
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | eq_ratio_of_proportion | [34, 1] | [91, 13] | obtain ⟨n, m, hrs_le_nm, hnm_le_tu, n_ne, m_ne⟩ := this | case pos
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
this : ∃ n m, r / s < ↑n / ↑m ∧ ↑n / ↑m < t / u ∧ n ≠ 0 ∧ m ≠ 0
⊢ False | case pos.intro.intro.intro.intro.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
n m : ℕ
hrs_le_nm : r / s < ↑n / ↑m
hnm_le_tu : ↑n / ↑m < t / u
n_ne : n ≠ 0
m_ne : m ≠ 0
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
this : ∃ n m, r / s < ↑n / ↑m ∧ ↑n / ↑m < t / u ∧ n ≠ 0 ∧ m ≠ 0
⊢ False
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | eq_ratio_of_proportion | [34, 1] | [91, 13] | have m_ne_ℝ : (m:ℝ) ≠ 0 := by exact_mod_cast m_ne | case pos.intro.intro.intro.intro.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
n m : ℕ
hrs_le_nm : r / s < ↑n / ↑m
hnm_le_tu : ↑n / ↑m < t / u
n_ne : n ≠ 0
m_ne : m ≠ 0
⊢ False | case pos.intro.intro.intro.intro.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
n m : ℕ
hrs_le_nm : r / s < ↑n / ↑m
hnm_le_tu : ↑n / ↑m < t / u
n_ne : n ≠ 0
m_ne : m ≠ 0
m_ne_ℝ : ↑m ≠ 0
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.intro.intro.intro.intro.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
n m : ℕ
hrs_le_nm : r / s < ↑n / ↑m
hnm_le_tu : ↑n / ↑m < t / u
n_ne : n ≠ 0
m_ne : m ≠ 0
⊢ False
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | eq_ratio_of_proportion | [34, 1] | [91, 13] | have mrns : (m:ℝ)*r < n*s → (m:ℝ) * t < n * u := by exact_mod_cast (h m n).2.1 | case pos.intro.intro.intro.intro.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
n m : ℕ
hrs_le_nm : r / s < ↑n / ↑m
hnm_le_tu : ↑n / ↑m < t / u
n_ne : n ≠ 0
m_ne : m ≠ 0
m_ne_ℝ : ↑m ≠ 0
⊢ False | case pos.intro.intro.intro.intro.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
n m : ℕ
hrs_le_nm : r / s < ↑n / ↑m
hnm_le_tu : ↑n / ↑m < t / u
n_ne : n ≠ 0
m_ne : m ≠ 0
m_ne_ℝ : ↑m ≠ 0
mrns : ↑m * r < ↑n * s → ↑m * t < ↑n * u
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.intro.intro.intro.intro.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
n m : ℕ
hrs_le_nm : r / s < ↑n / ↑m
hnm_le_tu : ↑n / ↑m < t / u
n_ne : n ≠ 0
m_ne : m ≠ 0
m_ne_ℝ : ↑m ≠ 0
⊢ False
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | eq_ratio_of_proportion | [34, 1] | [91, 13] | have' := mrns _ | case pos.intro.intro.intro.intro.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
n m : ℕ
hrs_le_nm : r / s < ↑n / ↑m
hnm_le_tu : ↑n / ↑m < t / u
n_ne : n ≠ 0
m_ne : m ≠ 0
m_ne_ℝ : ↑m ≠ 0
mrns : ↑m * r < ↑n * s → ↑m * t < ↑n * u
⊢ False | case pos.intro.intro.intro.intro.intro.refine'_2
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
n m : ℕ
hrs_le_nm : r / s < ↑n / ↑m
hnm_le_tu : ↑n / ↑m < t / u
n_ne : n ≠ 0
m_ne : m ≠ 0
m_ne_ℝ : ↑m ≠ 0
mrns : ↑m * r < ↑n * s → ↑m * t < ↑n * u
this : ↑m * t < ↑n * u
⊢ False
case pos.intro.intro.intro.intro.intro.refine'_1
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
n m : ℕ
hrs_le_nm : r / s < ↑n / ↑m
hnm_le_tu : ↑n / ↑m < t / u
n_ne : n ≠ 0
m_ne : m ≠ 0
m_ne_ℝ : ↑m ≠ 0
mrns : ↑m * r < ↑n * s → ↑m * t < ↑n * u
⊢ ↑m * r < ↑n * s | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.intro.intro.intro.intro.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
n m : ℕ
hrs_le_nm : r / s < ↑n / ↑m
hnm_le_tu : ↑n / ↑m < t / u
n_ne : n ≠ 0
m_ne : m ≠ 0
m_ne_ℝ : ↑m ≠ 0
mrns : ↑m * r < ↑n * s → ↑m * t < ↑n * u
⊢ False
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | eq_ratio_of_proportion | [34, 1] | [91, 13] | convert mul_lt_mul hrs_le_nm (by simp : s * m ≤ s * m) (by positivity) (by positivity) using 1 | case pos.intro.intro.intro.intro.intro.refine'_1
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
n m : ℕ
hrs_le_nm : r / s < ↑n / ↑m
hnm_le_tu : ↑n / ↑m < t / u
n_ne : n ≠ 0
m_ne : m ≠ 0
m_ne_ℝ : ↑m ≠ 0
mrns : ↑m * r < ↑n * s → ↑m * t < ↑n * u
⊢ ↑m * r < ↑n * s | case h.e'_3
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
n m : ℕ
hrs_le_nm : r / s < ↑n / ↑m
hnm_le_tu : ↑n / ↑m < t / u
n_ne : n ≠ 0
m_ne : m ≠ 0
m_ne_ℝ : ↑m ≠ 0
mrns : ↑m * r < ↑n * s → ↑m * t < ↑n * u
⊢ ↑m * r = r / s * (s * ↑m)
case h.e'_4
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
n m : ℕ
hrs_le_nm : r / s < ↑n / ↑m
hnm_le_tu : ↑n / ↑m < t / u
n_ne : n ≠ 0
m_ne : m ≠ 0
m_ne_ℝ : ↑m ≠ 0
mrns : ↑m * r < ↑n * s → ↑m * t < ↑n * u
⊢ ↑n * s = ↑n / ↑m * (s * ↑m) | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.intro.intro.intro.intro.intro.refine'_1
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
n m : ℕ
hrs_le_nm : r / s < ↑n / ↑m
hnm_le_tu : ↑n / ↑m < t / u
n_ne : n ≠ 0
m_ne : m ≠ 0
m_ne_ℝ : ↑m ≠ 0
mrns : ↑m * r < ↑n * s → ↑m * t < ↑n * u
⊢ ↑m * r < ↑n * s
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | eq_ratio_of_proportion | [34, 1] | [91, 13] | all_goals (field_simp; ring) | case h.e'_3
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
n m : ℕ
hrs_le_nm : r / s < ↑n / ↑m
hnm_le_tu : ↑n / ↑m < t / u
n_ne : n ≠ 0
m_ne : m ≠ 0
m_ne_ℝ : ↑m ≠ 0
mrns : ↑m * r < ↑n * s → ↑m * t < ↑n * u
⊢ ↑m * r = r / s * (s * ↑m)
case h.e'_4
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
n m : ℕ
hrs_le_nm : r / s < ↑n / ↑m
hnm_le_tu : ↑n / ↑m < t / u
n_ne : n ≠ 0
m_ne : m ≠ 0
m_ne_ℝ : ↑m ≠ 0
mrns : ↑m * r < ↑n * s → ↑m * t < ↑n * u
⊢ ↑n * s = ↑n / ↑m * (s * ↑m) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
n m : ℕ
hrs_le_nm : r / s < ↑n / ↑m
hnm_le_tu : ↑n / ↑m < t / u
n_ne : n ≠ 0
m_ne : m ≠ 0
m_ne_ℝ : ↑m ≠ 0
mrns : ↑m * r < ↑n * s → ↑m * t < ↑n * u
⊢ ↑m * r = r / s * (s * ↑m)
case h.e'_4
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
n m : ℕ
hrs_le_nm : r / s < ↑n / ↑m
hnm_le_tu : ↑n / ↑m < t / u
n_ne : n ≠ 0
m_ne : m ≠ 0
m_ne_ℝ : ↑m ≠ 0
mrns : ↑m * r < ↑n * s → ↑m * t < ↑n * u
⊢ ↑n * s = ↑n / ↑m * (s * ↑m)
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | eq_ratio_of_proportion | [34, 1] | [91, 13] | obtain ⟨q, hq⟩ := exists_rat_btwn rstu | case this
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
⊢ ∃ n m, r / s < ↑n / ↑m ∧ ↑n / ↑m < t / u ∧ n ≠ 0 ∧ m ≠ 0 | case this.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
q : ℚ
hq : r / s < ↑q ∧ ↑q < t / u
⊢ ∃ n m, r / s < ↑n / ↑m ∧ ↑n / ↑m < t / u ∧ n ≠ 0 ∧ m ≠ 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case this
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
⊢ ∃ n m, r / s < ↑n / ↑m ∧ ↑n / ↑m < t / u ∧ n ≠ 0 ∧ m ≠ 0
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | eq_ratio_of_proportion | [34, 1] | [91, 13] | have q_gt : (0:ℚ) < q := by
exact_mod_cast
calc (0:ℝ) ≤ r / s := by positivity
r / s < q := hq.1 | case this.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
q : ℚ
hq : r / s < ↑q ∧ ↑q < t / u
⊢ ∃ n m, r / s < ↑n / ↑m ∧ ↑n / ↑m < t / u ∧ n ≠ 0 ∧ m ≠ 0 | case this.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
q : ℚ
hq : r / s < ↑q ∧ ↑q < t / u
q_gt : 0 < q
⊢ ∃ n m, r / s < ↑n / ↑m ∧ ↑n / ↑m < t / u ∧ n ≠ 0 ∧ m ≠ 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case this.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
q : ℚ
hq : r / s < ↑q ∧ ↑q < t / u
⊢ ∃ n m, r / s < ↑n / ↑m ∧ ↑n / ↑m < t / u ∧ n ≠ 0 ∧ m ≠ 0
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | eq_ratio_of_proportion | [34, 1] | [91, 13] | let m := q.den | case this.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
q : ℚ
hq : r / s < ↑q ∧ ↑q < t / u
q_gt : 0 < q
⊢ ∃ n m, r / s < ↑n / ↑m ∧ ↑n / ↑m < t / u ∧ n ≠ 0 ∧ m ≠ 0 | case this.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
q : ℚ
hq : r / s < ↑q ∧ ↑q < t / u
q_gt : 0 < q
m : ℕ := q.den
⊢ ∃ n m, r / s < ↑n / ↑m ∧ ↑n / ↑m < t / u ∧ n ≠ 0 ∧ m ≠ 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case this.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
q : ℚ
hq : r / s < ↑q ∧ ↑q < t / u
q_gt : 0 < q
⊢ ∃ n m, r / s < ↑n / ↑m ∧ ↑n / ↑m < t / u ∧ n ≠ 0 ∧ m ≠ 0
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | eq_ratio_of_proportion | [34, 1] | [91, 13] | have m_ne : m ≠ 0 := q.den_nz | case this.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
q : ℚ
hq : r / s < ↑q ∧ ↑q < t / u
q_gt : 0 < q
m : ℕ := q.den
⊢ ∃ n m, r / s < ↑n / ↑m ∧ ↑n / ↑m < t / u ∧ n ≠ 0 ∧ m ≠ 0 | case this.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
q : ℚ
hq : r / s < ↑q ∧ ↑q < t / u
q_gt : 0 < q
m : ℕ := q.den
m_ne : m ≠ 0
⊢ ∃ n m, r / s < ↑n / ↑m ∧ ↑n / ↑m < t / u ∧ n ≠ 0 ∧ m ≠ 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case this.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
q : ℚ
hq : r / s < ↑q ∧ ↑q < t / u
q_gt : 0 < q
m : ℕ := q.den
⊢ ∃ n m, r / s < ↑n / ↑m ∧ ↑n / ↑m < t / u ∧ n ≠ 0 ∧ m ≠ 0
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | eq_ratio_of_proportion | [34, 1] | [91, 13] | let nn := q.num | case this.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
q : ℚ
hq : r / s < ↑q ∧ ↑q < t / u
q_gt : 0 < q
m : ℕ := q.den
m_ne : m ≠ 0
⊢ ∃ n m, r / s < ↑n / ↑m ∧ ↑n / ↑m < t / u ∧ n ≠ 0 ∧ m ≠ 0 | case this.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
q : ℚ
hq : r / s < ↑q ∧ ↑q < t / u
q_gt : 0 < q
m : ℕ := q.den
m_ne : m ≠ 0
nn : ℤ := q.num
⊢ ∃ n m, r / s < ↑n / ↑m ∧ ↑n / ↑m < t / u ∧ n ≠ 0 ∧ m ≠ 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case this.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
q : ℚ
hq : r / s < ↑q ∧ ↑q < t / u
q_gt : 0 < q
m : ℕ := q.den
m_ne : m ≠ 0
⊢ ∃ n m, r / s < ↑n / ↑m ∧ ↑n / ↑m < t / u ∧ n ≠ 0 ∧ m ≠ 0
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | eq_ratio_of_proportion | [34, 1] | [91, 13] | have nn_gt : 0 < nn := Rat.num_pos_iff_pos.mpr q_gt | case this.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
q : ℚ
hq : r / s < ↑q ∧ ↑q < t / u
q_gt : 0 < q
m : ℕ := q.den
m_ne : m ≠ 0
nn : ℤ := q.num
⊢ ∃ n m, r / s < ↑n / ↑m ∧ ↑n / ↑m < t / u ∧ n ≠ 0 ∧ m ≠ 0 | case this.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
q : ℚ
hq : r / s < ↑q ∧ ↑q < t / u
q_gt : 0 < q
m : ℕ := q.den
m_ne : m ≠ 0
nn : ℤ := q.num
nn_gt : 0 < nn
⊢ ∃ n m, r / s < ↑n / ↑m ∧ ↑n / ↑m < t / u ∧ n ≠ 0 ∧ m ≠ 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case this.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
q : ℚ
hq : r / s < ↑q ∧ ↑q < t / u
q_gt : 0 < q
m : ℕ := q.den
m_ne : m ≠ 0
nn : ℤ := q.num
⊢ ∃ n m, r / s < ↑n / ↑m ∧ ↑n / ↑m < t / u ∧ n ≠ 0 ∧ m ≠ 0
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | eq_ratio_of_proportion | [34, 1] | [91, 13] | let n := nn.toNat | case this.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
q : ℚ
hq : r / s < ↑q ∧ ↑q < t / u
q_gt : 0 < q
m : ℕ := q.den
m_ne : m ≠ 0
nn : ℤ := q.num
nn_gt : 0 < nn
⊢ ∃ n m, r / s < ↑n / ↑m ∧ ↑n / ↑m < t / u ∧ n ≠ 0 ∧ m ≠ 0 | case this.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
q : ℚ
hq : r / s < ↑q ∧ ↑q < t / u
q_gt : 0 < q
m : ℕ := q.den
m_ne : m ≠ 0
nn : ℤ := q.num
nn_gt : 0 < nn
n : ℕ := Int.toNat nn
⊢ ∃ n m, r / s < ↑n / ↑m ∧ ↑n / ↑m < t / u ∧ n ≠ 0 ∧ m ≠ 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case this.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
q : ℚ
hq : r / s < ↑q ∧ ↑q < t / u
q_gt : 0 < q
m : ℕ := q.den
m_ne : m ≠ 0
nn : ℤ := q.num
nn_gt : 0 < nn
⊢ ∃ n m, r / s < ↑n / ↑m ∧ ↑n / ↑m < t / u ∧ n ≠ 0 ∧ m ≠ 0
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | eq_ratio_of_proportion | [34, 1] | [91, 13] | have n_nn : (n:ℤ) = nn := Int.toNat_of_nonneg (le_of_lt nn_gt) | case this.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
q : ℚ
hq : r / s < ↑q ∧ ↑q < t / u
q_gt : 0 < q
m : ℕ := q.den
m_ne : m ≠ 0
nn : ℤ := q.num
nn_gt : 0 < nn
n : ℕ := Int.toNat nn
⊢ ∃ n m, r / s < ↑n / ↑m ∧ ↑n / ↑m < t / u ∧ n ≠ 0 ∧ m ≠ 0 | case this.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
q : ℚ
hq : r / s < ↑q ∧ ↑q < t / u
q_gt : 0 < q
m : ℕ := q.den
m_ne : m ≠ 0
nn : ℤ := q.num
nn_gt : 0 < nn
n : ℕ := Int.toNat nn
n_nn : ↑n = nn
⊢ ∃ n m, r / s < ↑n / ↑m ∧ ↑n / ↑m < t / u ∧ n ≠ 0 ∧ m ≠ 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case this.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
q : ℚ
hq : r / s < ↑q ∧ ↑q < t / u
q_gt : 0 < q
m : ℕ := q.den
m_ne : m ≠ 0
nn : ℤ := q.num
nn_gt : 0 < nn
n : ℕ := Int.toNat nn
⊢ ∃ n m, r / s < ↑n / ↑m ∧ ↑n / ↑m < t / u ∧ n ≠ 0 ∧ m ≠ 0
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | eq_ratio_of_proportion | [34, 1] | [91, 13] | use n, m | case this.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
q : ℚ
hq : r / s < ↑q ∧ ↑q < t / u
q_gt : 0 < q
m : ℕ := q.den
m_ne : m ≠ 0
nn : ℤ := q.num
nn_gt : 0 < nn
n : ℕ := Int.toNat nn
n_nn : ↑n = nn
⊢ ∃ n m, r / s < ↑n / ↑m ∧ ↑n / ↑m < t / u ∧ n ≠ 0 ∧ m ≠ 0 | case this.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
q : ℚ
hq : r / s < ↑q ∧ ↑q < t / u
q_gt : 0 < q
m : ℕ := q.den
m_ne : m ≠ 0
nn : ℤ := q.num
nn_gt : 0 < nn
n : ℕ := Int.toNat nn
n_nn : ↑n = nn
⊢ r / s < ↑n / ↑m ∧ ↑n / ↑m < t / u ∧ n ≠ 0 ∧ m ≠ 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case this.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
q : ℚ
hq : r / s < ↑q ∧ ↑q < t / u
q_gt : 0 < q
m : ℕ := q.den
m_ne : m ≠ 0
nn : ℤ := q.num
nn_gt : 0 < nn
n : ℕ := Int.toNat nn
n_nn : ↑n = nn
⊢ ∃ n m, r / s < ↑n / ↑m ∧ ↑n / ↑m < t / u ∧ n ≠ 0 ∧ m ≠ 0
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | eq_ratio_of_proportion | [34, 1] | [91, 13] | have : (n : ℝ) / m = q := by
have : (nn : ℝ) / m = q := by exact_mod_cast (q.num_den)
convert this using 2
exact_mod_cast Int.toNat_of_nonneg (le_of_lt nn_gt) | case this.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
q : ℚ
hq : r / s < ↑q ∧ ↑q < t / u
q_gt : 0 < q
m : ℕ := q.den
m_ne : m ≠ 0
nn : ℤ := q.num
nn_gt : 0 < nn
n : ℕ := Int.toNat nn
n_nn : ↑n = nn
⊢ r / s < ↑n / ↑m ∧ ↑n / ↑m < t / u ∧ n ≠ 0 ∧ m ≠ 0 | case this.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
q : ℚ
hq : r / s < ↑q ∧ ↑q < t / u
q_gt : 0 < q
m : ℕ := q.den
m_ne : m ≠ 0
nn : ℤ := q.num
nn_gt : 0 < nn
n : ℕ := Int.toNat nn
n_nn : ↑n = nn
this : ↑n / ↑m = ↑q
⊢ r / s < ↑n / ↑m ∧ ↑n / ↑m < t / u ∧ n ≠ 0 ∧ m ≠ 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case this.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
q : ℚ
hq : r / s < ↑q ∧ ↑q < t / u
q_gt : 0 < q
m : ℕ := q.den
m_ne : m ≠ 0
nn : ℤ := q.num
nn_gt : 0 < nn
n : ℕ := Int.toNat nn
n_nn : ↑n = nn
⊢ r / s < ↑n / ↑m ∧ ↑n / ↑m < t / u ∧ n ≠ 0 ∧ m ≠ 0
TACTIC:
|
https://github.com/ianjauslin-rutgers/pythagoras4.git | f97e5d2375d2e350b15d79e541520f8ba81600ec | Pythagoras/proportion.lean | eq_ratio_of_proportion | [34, 1] | [91, 13] | rw [this] | case this.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
q : ℚ
hq : r / s < ↑q ∧ ↑q < t / u
q_gt : 0 < q
m : ℕ := q.den
m_ne : m ≠ 0
nn : ℤ := q.num
nn_gt : 0 < nn
n : ℕ := Int.toNat nn
n_nn : ↑n = nn
this : ↑n / ↑m = ↑q
⊢ r / s < ↑n / ↑m ∧ ↑n / ↑m < t / u ∧ n ≠ 0 ∧ m ≠ 0 | case this.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
q : ℚ
hq : r / s < ↑q ∧ ↑q < t / u
q_gt : 0 < q
m : ℕ := q.den
m_ne : m ≠ 0
nn : ℤ := q.num
nn_gt : 0 < nn
n : ℕ := Int.toNat nn
n_nn : ↑n = nn
this : ↑n / ↑m = ↑q
⊢ r / s < ↑q ∧ ↑q < t / u ∧ n ≠ 0 ∧ m ≠ 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case this.intro
r s t u : ℝ
s_ne : s ≠ 0
u_ne : u ≠ 0
hr : 0 ≤ r
hs : 0 ≤ s
ht : 0 ≤ t
hu : 0 ≤ u
h :
∀ (n m : ℕ),
(↑n * r = ↑m * s → ↑n * t = ↑m * u) ∧ (↑n * r < ↑m * s → ↑n * t < ↑m * u) ∧ (↑m * s < ↑n * r → ↑m * u < ↑n * t)
hh : r / s ≠ t / u
rstu : r / s < t / u
q : ℚ
hq : r / s < ↑q ∧ ↑q < t / u
q_gt : 0 < q
m : ℕ := q.den
m_ne : m ≠ 0
nn : ℤ := q.num
nn_gt : 0 < nn
n : ℕ := Int.toNat nn
n_nn : ↑n = nn
this : ↑n / ↑m = ↑q
⊢ r / s < ↑n / ↑m ∧ ↑n / ↑m < t / u ∧ n ≠ 0 ∧ m ≠ 0
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.