ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Subgroup.mem_ofUnits_iff_exists_isUnit
@[to_additive]
lemma mem_ofUnits_iff_exists_isUnit (S : Subgroup Mˣ) (x : M) :
    x ∈ S.ofUnits ↔ ∃ h : IsUnit x, h.unit ∈ S 
Arguments: {M : Type u_1} [Monoid M] (S : Subgroup Mˣ) (x : M)
Goal: x ∈ S.ofUnits ↔ ∃ (h : IsUnit x), h.unit ∈ S
-- AddSubgroup.mem_ofAddUnits_iff_exists_isAddUnit
@[to_additive]
lemma mem_ofUnits_iff_exists_isUnit (S : Subgroup Mˣ) (x : M) :
    x ∈ S.ofUnits ↔ ∃ h : IsUnit x, h.unit ∈ S 
Arguments: {M : Type u_1} [AddMonoid M] (S : AddSubgroup (AddUnits M)) (x : M)
Goal: x ∈ S.ofAddUnits ↔ ∃ (h : IsAddUnit x), h.addUnit ∈ S
-- Subgroup.ofUnits_bot
@[to_additive (attr := simp)]
lemma ofUnits_bot : (⊥ : Subgroup Mˣ).ofUnits = ⊥ 
Arguments: {M : Type u_1} [Monoid M]
Goal: ⊥.ofUnits = ⊥
-- AddSubgroup.ofAddUnits_bot
@[to_additive (attr := simp)]
lemma ofUnits_bot : (⊥ : Subgroup Mˣ).ofUnits = ⊥ 
Arguments: {M : Type u_1} [AddMonoid M]
Goal: ⊥.ofAddUnits = ⊥
-- AddSubgroup.ofAddUnits_inf
@[to_additive]
lemma ofUnits_inf (S T : Subgroup Mˣ) : (S ⊔ T).ofUnits = S.ofUnits ⊔ T.ofUnits 
Arguments: {M : Type u_1} [AddMonoid M] (S T : AddSubgroup (AddUnits M))
Goal: (S ⊔ T).ofAddUnits = S.ofAddUnits ⊔ T.ofAddUnits
-- Subgroup.ofUnits_inf
@[to_additive]
lemma ofUnits_inf (S T : Subgroup Mˣ) : (S ⊔ T).ofUnits = S.ofUnits ⊔ T.ofUnits 
Arguments: {M : Type u_1} [Monoid M] (S T : Subgroup Mˣ)
Goal: (S ⊔ T).ofUnits = S.ofUnits ⊔ T.ofUnits
-- Subgroup.ofUnits_sSup
@[to_additive]
lemma ofUnits_sSup (s : Set (Subgroup Mˣ)) : (sSup s).ofUnits = ⨆ S ∈ s, S.ofUnits 
Arguments: {M : Type u_1} [Monoid M] (s : Set (Subgroup Mˣ))
Goal: (sSup s).ofUnits = ⨆ S ∈ s, S.ofUnits
-- AddSubgroup.ofAddUnits_sSup
@[to_additive]
lemma ofUnits_sSup (s : Set (Subgroup Mˣ)) : (sSup s).ofUnits = ⨆ S ∈ s, S.ofUnits 
Arguments: {M : Type u_1} [AddMonoid M] (s : Set (AddSubgroup (AddUnits M)))
Goal: (sSup s).ofAddUnits = ⨆ S ∈ s, S.ofAddUnits
-- AddSubgroup.ofAddUnits_iSup
@[to_additive]
lemma ofUnits_iSup {ι : Sort*} {f : ι → Subgroup Mˣ} :
    (iSup f).ofUnits = ⨆ (i : ι), (f i).ofUnits 
Arguments: {M : Type u_1} [AddMonoid M] {ι : Sort u_2} {f : ι → AddSubgroup (AddUnits M)}
Goal: (iSup f).ofAddUnits = ⨆ i, (f i).ofAddUnits
-- Subgroup.ofUnits_iSup
@[to_additive]
lemma ofUnits_iSup {ι : Sort*} {f : ι → Subgroup Mˣ} :
    (iSup f).ofUnits = ⨆ (i : ι), (f i).ofUnits 
Arguments: {M : Type u_1} [Monoid M] {ι : Sort u_2} {f : ι → Subgroup Mˣ}
Goal: (iSup f).ofUnits = ⨆ i, (f i).ofUnits
-- Subgroup.ofUnits_iSup₂
@[to_additive]
lemma ofUnits_iSup₂ {ι : Sort*} {κ : ι → Sort*} (f : (i : ι) → κ i → Subgroup Mˣ) :
    (⨆ (i : ι), ⨆ (j : κ i), f i j).ofUnits = ⨆ (i : ι), ⨆ (j : κ i), (f i j).ofUnits 
Arguments: {M : Type u_1} [Monoid M] {ι : Sort u_2} {κ : ι → Sort u_3} (f : (i : ι) → κ i → Subgroup Mˣ)
Goal: (⨆ i, ⨆ j, f i j).ofUnits = ⨆ i, ⨆ j, (f i j).ofUnits
-- AddSubgroup.ofAddUnits_iSup₂
@[to_additive]
lemma ofUnits_iSup₂ {ι : Sort*} {κ : ι → Sort*} (f : (i : ι) → κ i → Subgroup Mˣ) :
    (⨆ (i : ι), ⨆ (j : κ i), f i j).ofUnits = ⨆ (i : ι), ⨆ (j : κ i), (f i j).ofUnits 
Arguments: {M : Type u_1} [AddMonoid M] {ι : Sort u_2} {κ : ι → Sort u_3} (f : (i : ι) → κ i → AddSubgroup (AddUnits M))
Goal: (⨆ i, ⨆ j, f i j).ofAddUnits = ⨆ i, ⨆ j, (f i j).ofAddUnits
-- AddSubgroup.ofAddUnits_injective
@[to_additive]
lemma ofUnits_injective : Function.Injective (ofUnits (M := M)) 
Arguments: {M : Type u_1} [AddMonoid M]
Goal: Function.Injective AddSubgroup.ofAddUnits
-- Subgroup.ofUnits_injective
@[to_additive]
lemma ofUnits_injective : Function.Injective (ofUnits (M := M)) 
Arguments: {M : Type u_1} [Monoid M]
Goal: Function.Injective Subgroup.ofUnits
-- Subgroup.ofUnits_sup_units
@[to_additive (attr := simp)]
lemma ofUnits_sup_units (S T : Subgroup Mˣ) : (S.ofUnits ⊔ T.ofUnits).units = S ⊔ T 
Arguments: {M : Type u_1} [Monoid M] (S T : Subgroup Mˣ)
Goal: (S.ofUnits ⊔ T.ofUnits).units = S ⊔ T
-- AddSubgroup.ofAddUnits_sup_addUnits
@[to_additive (attr := simp)]
lemma ofUnits_sup_units (S T : Subgroup Mˣ) : (S.ofUnits ⊔ T.ofUnits).units = S ⊔ T 
Arguments: {M : Type u_1} [AddMonoid M] (S T : AddSubgroup (AddUnits M))
Goal: (S.ofAddUnits ⊔ T.ofAddUnits).addUnits = S ⊔ T
-- AddSubgroup.ofAddUnits_inf_addUnits
@[to_additive (attr := simp)]
lemma ofUnits_inf_units (S T : Subgroup Mˣ) : (S.ofUnits ⊓ T.ofUnits).units = S ⊓ T 
Arguments: {M : Type u_1} [AddMonoid M] (S T : AddSubgroup (AddUnits M))
Goal: (S.ofAddUnits ⊓ T.ofAddUnits).addUnits = S ⊓ T
-- Subgroup.ofUnits_inf_units
@[to_additive (attr := simp)]
lemma ofUnits_inf_units (S T : Subgroup Mˣ) : (S.ofUnits ⊓ T.ofUnits).units = S ⊓ T 
Arguments: {M : Type u_1} [Monoid M] (S T : Subgroup Mˣ)
Goal: (S.ofUnits ⊓ T.ofUnits).units = S ⊓ T
-- Subgroup.ofUnits_right_inverse
@[to_additive]
lemma ofUnits_right_inverse :
    Function.RightInverse (ofUnits (M := M)) (Submonoid.units (M := M)) 
Arguments: {M : Type u_1} [Monoid M]
Goal: Function.RightInverse Subgroup.ofUnits Submonoid.units
-- AddSubgroup.ofAddUnits_right_inverse
@[to_additive]
lemma ofUnits_right_inverse :
    Function.RightInverse (ofUnits (M := M)) (Submonoid.units (M := M)) 
Arguments: {M : Type u_1} [AddMonoid M]
Goal: Function.RightInverse AddSubgroup.ofAddUnits AddSubmonoid.addUnits
-- Subgroup.ofUnits_strictMono
@[to_additive]
lemma ofUnits_strictMono : StrictMono (ofUnits (M := M)) 
Arguments: {M : Type u_1} [Monoid M]
Goal: StrictMono Subgroup.ofUnits
-- AddSubgroup.ofAddUnits_strictMono
@[to_additive]
lemma ofUnits_strictMono : StrictMono (ofUnits (M := M)) 
Arguments: {M : Type u_1} [AddMonoid M]
Goal: StrictMono AddSubgroup.ofAddUnits
-- Subgroup.ofUnits_le_ofUnits_iff
lemma ofUnits_le_ofUnits_iff {S T : Subgroup Mˣ} : S.ofUnits ≤ T.ofUnits ↔ S ≤ T 
Arguments: {M : Type u_1} [Monoid M] {S T : Subgroup Mˣ}
Goal: S.ofUnits ≤ T.ofUnits ↔ S ≤ T
-- Subgroup.mem_units_iff_val_mem
@[to_additive]
lemma mem_units_iff_val_mem (H : Subgroup G) (x : Gˣ) : x ∈ H.units ↔ (x : G) ∈ H 
Arguments: {G : Type u_2} [Group G] (H : Subgroup G) (x : Gˣ)
Goal: x ∈ H.units ↔ ↑x ∈ H
-- AddSubgroup.mem_addUnits_iff_val_mem
@[to_additive]
lemma mem_units_iff_val_mem (H : Subgroup G) (x : Gˣ) : x ∈ H.units ↔ (x : G) ∈ H 
Arguments: {G : Type u_2} [AddGroup G] (H : AddSubgroup G) (x : AddUnits G)
Goal: x ∈ H.addUnits ↔ ↑x ∈ H
-- Subgroup.mem_ofUnits_iff_toUnits_mem
@[to_additive]
lemma mem_ofUnits_iff_toUnits_mem (H : Subgroup Gˣ) (x : G) : x ∈ H.ofUnits ↔ (toUnits x) ∈ H 
Arguments: {G : Type u_2} [Group G] (H : Subgroup Gˣ) (x : G)
Goal: x ∈ H.ofUnits ↔ toUnits x ∈ H
-- AddSubgroup.mem_ofAddUnits_iff_toAddUnits_mem
@[to_additive]
lemma mem_ofUnits_iff_toUnits_mem (H : Subgroup Gˣ) (x : G) : x ∈ H.ofUnits ↔ (toUnits x) ∈ H 
Arguments: {G : Type u_2} [AddGroup G] (H : AddSubgroup (AddUnits G)) (x : G)
Goal: x ∈ H.ofAddUnits ↔ toAddUnits x ∈ H
-- AddSubgroup.mem_iff_toAddUnits_mem_addUnits
@[to_additive (attr := simp)]
lemma mem_iff_toUnits_mem_units (H : Subgroup G) (x : G) : toUnits x ∈ H.units ↔ x ∈ H 
Arguments: {G : Type u_2} [AddGroup G] (H : AddSubgroup G) (x : G)
Goal: toAddUnits x ∈ H.addUnits ↔ x ∈ H
-- Subgroup.mem_iff_toUnits_mem_units
@[to_additive (attr := simp)]
lemma mem_iff_toUnits_mem_units (H : Subgroup G) (x : G) : toUnits x ∈ H.units ↔ x ∈ H 
Arguments: {G : Type u_2} [Group G] (H : Subgroup G) (x : G)
Goal: toUnits x ∈ H.units ↔ x ∈ H
-- Subgroup.val_mem_ofUnits_iff_mem
@[to_additive (attr := simp)]
lemma val_mem_ofUnits_iff_mem (H : Subgroup Gˣ) (x : Gˣ) : (x : G) ∈ H.ofUnits ↔ x ∈ H 
Arguments: {G : Type u_2} [Group G] (H : Subgroup Gˣ) (x : Gˣ)
Goal: ↑x ∈ H.ofUnits ↔ x ∈ H
-- AddSubgroup.val_mem_ofAddUnits_iff_mem
@[to_additive (attr := simp)]
lemma val_mem_ofUnits_iff_mem (H : Subgroup Gˣ) (x : Gˣ) : (x : G) ∈ H.ofUnits ↔ x ∈ H 
Arguments: {G : Type u_2} [AddGroup G] (H : AddSubgroup (AddUnits G)) (x : AddUnits G)
Goal: ↑x ∈ H.ofAddUnits ↔ x ∈ H
-- Int.toAdd_pow
lemma toAdd_pow (a : Multiplicative ℤ) (b : ℕ) : toAdd (a ^ b) = toAdd a * b 
Arguments: (a : Multiplicative ℤ) (b : ℕ)
Goal: Multiplicative.toAdd (a ^ b) = Multiplicative.toAdd a * ↑b
-- Int.toAdd_zpow
lemma toAdd_zpow (a : Multiplicative ℤ) (b : ℤ) : toAdd (a ^ b) = toAdd a * b 
Arguments: (a : Multiplicative ℤ) (b : ℤ)
Goal: Multiplicative.toAdd (a ^ b) = Multiplicative.toAdd a * b
-- Int.ofAdd_mul
@[simp] lemma ofAdd_mul (a b : ℤ) : ofAdd (a * b) = ofAdd a ^ b 
Arguments: (a b : ℤ)
Goal: Multiplicative.ofAdd (a * b) = Multiplicative.ofAdd a ^ b
-- Int.units_natAbs
lemma units_natAbs (u : ℤˣ) : natAbs u = 1 
Arguments: (u : ℤˣ)
Goal: (↑u).natAbs = 1
-- Int.natAbs_of_isUnit
@[simp] lemma natAbs_of_isUnit (hu : IsUnit u) : natAbs u = 1 
Arguments: {u : ℤ} (hu : IsUnit u)
Goal: u.natAbs = 1
-- Int.isUnit_eq_one_or
lemma isUnit_eq_one_or (hu : IsUnit u) : u = 1 ∨ u = -1 
Arguments: {u : ℤ} (hu : IsUnit u)
Goal: u = 1 ∨ u = -1
-- Int.isUnit_ne_iff_eq_neg
lemma isUnit_ne_iff_eq_neg (hu : IsUnit u) (hv : IsUnit v) : u ≠ v ↔ u = -v 
Arguments: {u v : ℤ} (hu : IsUnit u) (hv : IsUnit v)
Goal: u ≠ v ↔ u = -v
-- Int.isUnit_eq_or_eq_neg
lemma isUnit_eq_or_eq_neg (hu : IsUnit u) (hv : IsUnit v) : u = v ∨ u = -v 
Arguments: {u v : ℤ} (hu : IsUnit u) (hv : IsUnit v)
Goal: u = v ∨ u = -v
-- Int.isUnit_iff
lemma isUnit_iff : IsUnit u ↔ u = 1 ∨ u = -1 
Arguments: {u : ℤ}
Goal: IsUnit u ↔ u = 1 ∨ u = -1
-- Int.eq_one_or_neg_one_of_mul_eq_one
lemma eq_one_or_neg_one_of_mul_eq_one (h : u * v = 1) : u = 1 ∨ u = -1 
Arguments: {u v : ℤ} (h : u * v = 1)
Goal: u = 1 ∨ u = -1
-- Int.eq_one_or_neg_one_of_mul_eq_one'
lemma eq_one_or_neg_one_of_mul_eq_one' (h : u * v = 1) : u = 1 ∧ v = 1 ∨ u = -1 ∧ v = -1 
Arguments: {u v : ℤ} (h : u * v = 1)
Goal: u = 1 ∧ v = 1 ∨ u = -1 ∧ v = -1
-- Int.eq_of_mul_eq_one
lemma eq_of_mul_eq_one (h : u * v = 1) : u = v 
Arguments: {u v : ℤ} (h : u * v = 1)
Goal: u = v
-- Int.mul_eq_one_iff_eq_one_or_neg_one
lemma mul_eq_one_iff_eq_one_or_neg_one : u * v = 1 ↔ u = 1 ∧ v = 1 ∨ u = -1 ∧ v = -1 
Arguments: {u v : ℤ}
Goal: u * v = 1 ↔ u = 1 ∧ v = 1 ∨ u = -1 ∧ v = -1
-- Int.eq_one_or_neg_one_of_mul_eq_neg_one'
lemma eq_one_or_neg_one_of_mul_eq_neg_one' (h : u * v = -1) : u = 1 ∧ v = -1 ∨ u = -1 ∧ v = 1 
Arguments: {u v : ℤ} (h : u * v = -1)
Goal: u = 1 ∧ v = -1 ∨ u = -1 ∧ v = 1
-- Int.mul_eq_neg_one_iff_eq_one_or_neg_one
lemma mul_eq_neg_one_iff_eq_one_or_neg_one : u * v = -1 ↔ u = 1 ∧ v = -1 ∨ u = -1 ∧ v = 1 
Arguments: {u v : ℤ}
Goal: u * v = -1 ↔ u = 1 ∧ v = -1 ∨ u = -1 ∧ v = 1
-- Int.isUnit_iff_natAbs_eq
lemma isUnit_iff_natAbs_eq : IsUnit u ↔ u.natAbs = 1 
Arguments: {u : ℤ}
Goal: IsUnit u ↔ u.natAbs = 1
-- Int.ofNat_isUnit
@[norm_cast]
lemma ofNat_isUnit {n : ℕ} : IsUnit (n : ℤ) ↔ IsUnit n 
Arguments: {n : ℕ}
Goal: IsUnit ↑n ↔ IsUnit n
-- Int.isUnit_mul_self
lemma isUnit_mul_self (hu : IsUnit u) : u * u = 1 
Arguments: {u : ℤ} (hu : IsUnit u)
Goal: u * u = 1
-- Int.isUnit_add_isUnit_eq_isUnit_add_isUnit
lemma isUnit_add_isUnit_eq_isUnit_add_isUnit {a b c d : ℤ} (ha : IsUnit a) (hb : IsUnit b)
    (hc : IsUnit c) (hd : IsUnit d) : a + b = c + d ↔ a = c ∧ b = d ∨ a = d ∧ b = c 
Arguments: {a b c d : ℤ} (ha : IsUnit a) (hb : IsUnit b) (hc : IsUnit c) (hd : IsUnit d)
Goal: a + b = c + d ↔ a = c ∧ b = d ∨ a = d ∧ b = c
-- Int.eq_one_or_neg_one_of_mul_eq_neg_one
lemma eq_one_or_neg_one_of_mul_eq_neg_one (h : u * v = -1) : u = 1 ∨ u = -1 
Arguments: {u v : ℤ} (h : u * v = -1)
Goal: u = 1 ∨ u = -1
-- Int.emod_two_ne_one
@[simp] lemma emod_two_ne_one : ¬n % 2 = 1 ↔ n % 2 = 0 
Arguments: {n : ℤ}
Goal: ¬n % 2 = 1 ↔ n % 2 = 0
-- Int.one_emod_two
@[simp] lemma one_emod_two : (1 : Int) % 2 = 1 
Goal: 1 % 2 = 1
-- Int.emod_two_ne_zero
@[local simp] lemma emod_two_ne_zero : ¬n % 2 = 0 ↔ n % 2 = 1 
Arguments: {n : ℤ}
Goal: ¬n % 2 = 0 ↔ n % 2 = 1
-- Int.even_iff
lemma even_iff : Even n ↔ n % 2 = 0 
Arguments: {n : ℤ}
Goal: Even n ↔ n % 2 = 0
-- Int.not_even_iff
lemma not_even_iff : ¬Even n ↔ n % 2 = 1 
Arguments: {n : ℤ}
Goal: ¬Even n ↔ n % 2 = 1
-- Int.two_dvd_ne_zero
@[simp] lemma two_dvd_ne_zero : ¬2 ∣ n ↔ n % 2 = 1 
Arguments: {n : ℤ}
Goal: ¬2 ∣ n ↔ n % 2 = 1
-- Int.not_even_one
@[simp] lemma not_even_one : ¬Even (1 : ℤ) 
Goal: ¬Even 1
-- Int.even_add
@[parity_simps] lemma even_add : Even (m + n) ↔ (Even m ↔ Even n) 
Arguments: {m n : ℤ}
Goal: Even (m + n) ↔ (Even m ↔ Even n)
-- Int.two_not_dvd_two_mul_add_one
lemma two_not_dvd_two_mul_add_one (n : ℤ) : ¬2 ∣ 2 * n + 1 
Arguments: (n : ℤ)
Goal: ¬2 ∣ 2 * n + 1
-- Int.even_sub
@[parity_simps]
lemma even_sub : Even (m - n) ↔ (Even m ↔ Even n) 
Arguments: {m n : ℤ}
Goal: Even (m - n) ↔ (Even m ↔ Even n)
-- Int.even_add_one
@[parity_simps] lemma even_add_one : Even (n + 1) ↔ ¬Even n 
Arguments: {n : ℤ}
Goal: Even (n + 1) ↔ ¬Even n
-- Int.even_sub_one
@[parity_simps] lemma even_sub_one : Even (n - 1) ↔ ¬Even n 
Arguments: {n : ℤ}
Goal: Even (n - 1) ↔ ¬Even n
-- Int.even_mul
@[parity_simps] lemma even_mul : Even (m * n) ↔ Even m ∨ Even n 
Arguments: {m n : ℤ}
Goal: Even (m * n) ↔ Even m ∨ Even n
-- Int.even_pow
@[parity_simps] lemma even_pow {n : ℕ} : Even (m ^ n) ↔ Even m ∧ n ≠ 0 
Arguments: {m : ℤ} {n : ℕ}
Goal: Even (m ^ n) ↔ Even m ∧ n ≠ 0
-- Int.even_pow'
lemma even_pow' {n : ℕ} (h : n ≠ 0) : Even (m ^ n) ↔ Even m 
Arguments: {m : ℤ} {n : ℕ} (h : n ≠ 0)
Goal: Even (m ^ n) ↔ Even m
-- Int.even_coe_nat
@[simp, norm_cast] lemma even_coe_nat (n : ℕ) : Even (n : ℤ) ↔ Even n 
Arguments: (n : ℕ)
Goal: Even ↑n ↔ Even n
-- Int.two_mul_ediv_two_of_even
lemma two_mul_ediv_two_of_even : Even n → 2 * (n / 2) = n 
Arguments: {n : ℤ}
Goal: Even n → 2 * (n / 2) = n
-- Int.ediv_two_mul_two_of_even
lemma ediv_two_mul_two_of_even : Even n → n / 2 * 2 = n 
Arguments: {n : ℤ}
Goal: Even n → n / 2 * 2 = n
-- zsmul_int_int
lemma zsmul_int_int (a b : ℤ) : a • b = a * b 
Arguments: (a b : ℤ)
Goal: a • b = a * b
-- zsmul_int_one
lemma zsmul_int_one (n : ℤ) : n • (1 : ℤ) = n 
Arguments: (n : ℤ)
Goal: n • 1 = n
-- GenContFract.squashSeq_eq_self_of_terminated
theorem squashSeq_eq_self_of_terminated (terminatedAt_succ_n : s.TerminatedAt (n + 1)) :
    squashSeq s n = s 
Arguments: {K : Type u_1} {n : ℕ} {s : Stream'.Seq (GenContFract.Pair K)} [DivisionRing K] (terminatedAt_succ_n : s.TerminatedAt (n + 1))
Goal: GenContFract.squashSeq s n = s
-- GenContFract.squashSeq_nth_of_not_terminated
theorem squashSeq_nth_of_not_terminated {gp_n gp_succ_n : Pair K} (s_nth_eq : s.get? n = some gp_n)
    (s_succ_nth_eq : s.get? (n + 1) = some gp_succ_n) :
    (squashSeq s n).get? n = some ⟨gp_n.a, gp_n.b + gp_succ_n.a / gp_succ_n.b⟩ 
Arguments: {K : Type u_1} {n : ℕ} {s : Stream'.Seq (GenContFract.Pair K)} [DivisionRing K] {gp_n gp_succ_n : GenContFract.Pair K} (s_nth_eq : s.get? n = some gp_n) (s_succ_nth_eq : s.get? (n + 1) = some gp_succ_n)
Goal: (GenContFract.squashSeq s n).get? n = some { a := gp_n.a, b := gp_n.b + gp_succ_n.a / gp_succ_n.b }
-- GenContFract.squashSeq_nth_of_lt
theorem squashSeq_nth_of_lt {m : ℕ} (m_lt_n : m < n) : (squashSeq s n).get? m = s.get? m 
Arguments: {K : Type u_1} {n : ℕ} {s : Stream'.Seq (GenContFract.Pair K)} [DivisionRing K] {m : ℕ} (m_lt_n : m < n)
Goal: (GenContFract.squashSeq s n).get? m = s.get? m
-- GenContFract.squashSeq_succ_n_tail_eq_squashSeq_tail_n
theorem squashSeq_succ_n_tail_eq_squashSeq_tail_n :
    (squashSeq s (n + 1)).tail = squashSeq s.tail n 
Arguments: {K : Type u_1} {n : ℕ} {s : Stream'.Seq (GenContFract.Pair K)} [DivisionRing K]
Goal: (GenContFract.squashSeq s (n + 1)).tail = GenContFract.squashSeq s.tail n
-- GenContFract.succ_succ_nth_conv'Aux_eq_succ_nth_conv'Aux_squashSeq
theorem succ_succ_nth_conv'Aux_eq_succ_nth_conv'Aux_squashSeq :
    convs'Aux s (n + 2) = convs'Aux (squashSeq s n) (n + 1) 
Arguments: {K : Type u_1} {n : ℕ} {s : Stream'.Seq (GenContFract.Pair K)} [DivisionRing K]
Goal: GenContFract.convs'Aux s (n + 2) = GenContFract.convs'Aux (GenContFract.squashSeq s n) (n + 1)
-- GenContFract.squashGCF_eq_self_of_terminated
theorem squashGCF_eq_self_of_terminated (terminatedAt_n : TerminatedAt g n) :
    squashGCF g n = g 
Arguments: {K : Type u_1} {n : ℕ} {g : GenContFract K} [DivisionRing K] (terminatedAt_n : g.TerminatedAt n)
Goal: g.squashGCF n = g
-- GenContFract.squashGCF_nth_of_lt
theorem squashGCF_nth_of_lt {m : ℕ} (m_lt_n : m < n) :
    (squashGCF g (n + 1)).s.get? m = g.s.get? m 
Arguments: {K : Type u_1} {n : ℕ} {g : GenContFract K} [DivisionRing K] {m : ℕ} (m_lt_n : m < n)
Goal: (g.squashGCF (n + 1)).s.get? m = g.s.get? m
-- GenContFract.succ_nth_conv'_eq_squashGCF_nth_conv'
theorem succ_nth_conv'_eq_squashGCF_nth_conv' :
    g.convs' (n + 1) = (squashGCF g n).convs' n 
Arguments: {K : Type u_1} {n : ℕ} {g : GenContFract K} [DivisionRing K]
Goal: g.convs' (n + 1) = (g.squashGCF n).convs' n
-- GenContFract.contsAux_eq_contsAux_squashGCF_of_le
theorem contsAux_eq_contsAux_squashGCF_of_le {m : ℕ} :
    m ≤ n → contsAux g m = (squashGCF g n).contsAux m 
Arguments: {K : Type u_1} {n : ℕ} {g : GenContFract K} [DivisionRing K] {m : ℕ}
Goal: m ≤ n → g.contsAux m = (g.squashGCF n).contsAux m
-- GenContFract.succ_nth_conv_eq_squashGCF_nth_conv
theorem succ_nth_conv_eq_squashGCF_nth_conv [Field K]
    (nth_partDen_ne_zero : ∀ {b : K}, g.partDens.get? n = some b → b ≠ 0) :
    g.convs (n + 1) = (squashGCF g n).convs n 
Arguments: {K : Type u_1} {n : ℕ} {g : GenContFract K} [Field K] (nth_partDen_ne_zero : ∀ {b : K}, g.partDens.get? n = some b → b ≠ 0)
Goal: g.convs (n + 1) = (g.squashGCF n).convs n
-- GenContFract.convs_eq_convs'
theorem convs_eq_convs' [LinearOrderedField K]
    (s_pos : ∀ {gp : Pair K} {m : ℕ}, m < n → g.s.get? m = some gp → 0 < gp.a ∧ 0 < gp.b) :
    g.convs n = g.convs' n 
Arguments: {K : Type u_1} {n : ℕ} {g : GenContFract K} [LinearOrderedField K] (s_pos : ∀ {gp : GenContFract.Pair K} {m : ℕ}, m < n → g.s.get? m = some gp → 0 < gp.a ∧ 0 < gp.b)
Goal: g.convs n = g.convs' n
-- ContFract.convs_eq_convs'
nonrec theorem convs_eq_convs' [LinearOrderedField K] {c : ContFract K} :
    (↑c : GenContFract K).convs = (↑c : GenContFract K).convs' 
Arguments: {K : Type u_1} [LinearOrderedField K] {c : ContFract K}
Goal: (↑↑c).convs = (↑↑c).convs'
-- IsConj.refl
@[refl]
theorem IsConj.refl (a : α) : IsConj a a 
Arguments: {α : Type u} [Monoid α] (a : α)
Goal: IsConj a a
-- IsConj.symm
@[symm]
theorem IsConj.symm {a b : α} : IsConj a b → IsConj b a
  
Arguments: {α : Type u} [Monoid α] {a b : α}
Goal: IsConj a b → IsConj b a
-- isConj_comm
theorem isConj_comm {g h : α} : IsConj g h ↔ IsConj h g 
Arguments: {α : Type u} [Monoid α] {g h : α}
Goal: IsConj g h ↔ IsConj h g
-- IsConj.trans
@[trans]
theorem IsConj.trans {a b c : α} : IsConj a b → IsConj b c → IsConj a c
  
Arguments: {α : Type u} [Monoid α] {a b c : α}
Goal: IsConj a b → IsConj b c → IsConj a c
-- isConj_iff_eq
@[simp]
theorem isConj_iff_eq {α : Type*} [CommMonoid α] {a b : α} : IsConj a b ↔ a = b 
Arguments: {α : Type u_1} [CommMonoid α] {a b : α}
Goal: IsConj a b ↔ a = b
-- MonoidHom.map_isConj
protected theorem MonoidHom.map_isConj (f : α →* β) {a b : α} : IsConj a b → IsConj (f a) (f b)
  
Arguments: {α : Type u} {β : Type v} [Monoid α] [Monoid β] (f : α →* β) {a b : α}
Goal: IsConj a b → IsConj (f a) (f b)
-- isConj_one_right
@[simp]
theorem isConj_one_right {a : α} : IsConj 1 a ↔ a = 1 
Arguments: {α : Type u} [CancelMonoid α] {a : α}
Goal: IsConj 1 a ↔ a = 1
-- isConj_one_left
@[simp]
theorem isConj_one_left {a : α} : IsConj a 1 ↔ a = 1 
Arguments: {α : Type u} [CancelMonoid α] {a : α}
Goal: IsConj a 1 ↔ a = 1
-- isConj_iff
@[simp]
theorem isConj_iff {a b : α} : IsConj a b ↔ ∃ c : α, c * a * c⁻¹ = b 
Arguments: {α : Type u} [Group α] {a b : α}
Goal: IsConj a b ↔ ∃ c, c * a * c⁻¹ = b
-- conj_inv
theorem conj_inv {a b : α} : (b * a * b⁻¹)⁻¹ = b * a⁻¹ * b⁻¹ 
Arguments: {α : Type u} [Group α] {a b : α}
Goal: (b * a * b⁻¹)⁻¹ = b * a⁻¹ * b⁻¹
-- conj_mul
@[simp]
theorem conj_mul {a b c : α} : b * a * b⁻¹ * (b * c * b⁻¹) = b * (a * c) * b⁻¹ 
Arguments: {α : Type u} [Group α] {a b c : α}
Goal: b * a * b⁻¹ * (b * c * b⁻¹) = b * (a * c) * b⁻¹
-- conj_pow
@[simp]
theorem conj_pow {i : ℕ} {a b : α} : (a * b * a⁻¹) ^ i = a * b ^ i * a⁻¹ 
Arguments: {α : Type u} [Group α] {i : ℕ} {a b : α}
Goal: (a * b * a⁻¹) ^ i = a * b ^ i * a⁻¹
-- conj_zpow
@[simp]
theorem conj_zpow {i : ℤ} {a b : α} : (a * b * a⁻¹) ^ i = a * b ^ i * a⁻¹ 
Arguments: {α : Type u} [Group α] {i : ℤ} {a b : α}
Goal: (a * b * a⁻¹) ^ i = a * b ^ i * a⁻¹
-- conj_injective
theorem conj_injective {x : α} : Function.Injective fun g : α => x * g * x⁻¹ 
Arguments: {α : Type u} [Group α] {x : α}
Goal: Function.Injective fun g => x * g * x⁻¹
-- ConjClasses.mk_eq_mk_iff_isConj
theorem mk_eq_mk_iff_isConj {a b : α} : ConjClasses.mk a = ConjClasses.mk b ↔ IsConj a b 
Arguments: {α : Type u} [Monoid α] {a b : α}
Goal: ConjClasses.mk a = ConjClasses.mk b ↔ IsConj a b
-- ConjClasses.quotient_mk_eq_mk
theorem quotient_mk_eq_mk (a : α) : ⟦a⟧ = ConjClasses.mk a 
Arguments: {α : Type u} [Monoid α] (a : α)
Goal: ⟦a⟧ = ConjClasses.mk a
-- ConjClasses.quot_mk_eq_mk
theorem quot_mk_eq_mk (a : α) : Quot.mk Setoid.r a = ConjClasses.mk a 
Arguments: {α : Type u} [Monoid α] (a : α)
Goal: Quot.mk Setoid.r a = ConjClasses.mk a
-- ConjClasses.forall_isConj
theorem forall_isConj {p : ConjClasses α → Prop} : (∀ a, p a) ↔ ∀ a, p (ConjClasses.mk a) 
Arguments: {α : Type u} [Monoid α] {p : ConjClasses α → Prop}
Goal: (∀ (a : ConjClasses α), p a) ↔ ∀ (a : α), p (ConjClasses.mk a)
-- ConjClasses.mk_surjective
theorem mk_surjective : Function.Surjective (@ConjClasses.mk α _) 
Arguments: {α : Type u} [Monoid α]
Goal: Function.Surjective ConjClasses.mk
-- ConjClasses.one_eq_mk_one
theorem one_eq_mk_one : (1 : ConjClasses α) = ConjClasses.mk 1 
Arguments: {α : Type u} [Monoid α]
Goal: 1 = ConjClasses.mk 1
-- ConjClasses.exists_rep
theorem exists_rep (a : ConjClasses α) : ∃ a0 : α, ConjClasses.mk a0 = a 
Arguments: {α : Type u} [Monoid α] (a : ConjClasses α)
Goal: ∃ a0, ConjClasses.mk a0 = a
-- ConjClasses.map_surjective
theorem map_surjective {f : α →* β} (hf : Function.Surjective f) :
    Function.Surjective (ConjClasses.map f) 
Arguments: {α : Type u} {β : Type v} [Monoid α] [Monoid β] {f : α →* β} (hf : Function.Surjective ⇑f)
Goal: Function.Surjective (ConjClasses.map f)
-- ConjClasses.mk_injective
theorem mk_injective : Function.Injective (@ConjClasses.mk α _) 
Arguments: {α : Type u} [CommMonoid α]
Goal: Function.Injective ConjClasses.mk
-- ConjClasses.mk_bijective
theorem mk_bijective : Function.Bijective (@ConjClasses.mk α _) 
Arguments: {α : Type u} [CommMonoid α]
Goal: Function.Bijective ConjClasses.mk
-- mem_conjugatesOf_self
theorem mem_conjugatesOf_self {a : α} : a ∈ conjugatesOf a 
Arguments: {α : Type u} [Monoid α] {a : α}
Goal: a ∈ conjugatesOf a
-- IsConj.conjugatesOf_eq
theorem IsConj.conjugatesOf_eq {a b : α} (ab : IsConj a b) : conjugatesOf a = conjugatesOf b 
Arguments: {α : Type u} [Monoid α] {a b : α} (ab : IsConj a b)
Goal: conjugatesOf a = conjugatesOf b
-- isConj_iff_conjugatesOf_eq
theorem isConj_iff_conjugatesOf_eq {a b : α} : IsConj a b ↔ conjugatesOf a = conjugatesOf b 
Arguments: {α : Type u} [Monoid α] {a b : α}
Goal: IsConj a b ↔ conjugatesOf a = conjugatesOf b
-- ConjClasses.mem_carrier_mk
theorem mem_carrier_mk {a : α} : a ∈ carrier (ConjClasses.mk a) 
Arguments: {α : Type u} [Monoid α] {a : α}
Goal: a ∈ (ConjClasses.mk a).carrier
-- ConjClasses.mem_carrier_iff_mk_eq
theorem mem_carrier_iff_mk_eq {a : α} {b : ConjClasses α} :
    a ∈ carrier b ↔ ConjClasses.mk a = b 
Arguments: {α : Type u} [Monoid α] {a : α} {b : ConjClasses α}
Goal: a ∈ b.carrier ↔ ConjClasses.mk a = b
-- ConjClasses.carrier_eq_preimage_mk
theorem carrier_eq_preimage_mk {a : ConjClasses α} : a.carrier = ConjClasses.mk ⁻¹' {a} 
Arguments: {α : Type u} [Monoid α] {a : ConjClasses α}
Goal: a.carrier = ConjClasses.mk ⁻¹' {a}
-- OneMemClass.one_mem
class OneMemClass (S : Type*) (M : Type*) [One M] [SetLike S M] : Prop where
    one_mem : ∀ s : S, (1 : M) ∈ s
Arguments: {S : Type u_4} {M : Type u_5} [One M] [SetLike S M] [self : OneMemClass S M] (s : S)
Goal: 1 ∈ s
-- ZeroMemClass.zero_mem
class ZeroMemClass (S : Type*) (M : Type*) [Zero M] [SetLike S M] : Prop where
    zero_mem : ∀ s : S, (0 : M) ∈ s
Arguments: {S : Type u_4} {M : Type u_5} [Zero M] [SetLike S M] [self : ZeroMemClass S M] (s : S)
Goal: 0 ∈ s
-- Submonoid.one_mem'
structure Submonoid (M : Type*) [MulOneClass M] extends Subsemigroup M where
    one_mem' : (1 : M) ∈ carrier
Arguments: {M : Type u_4} [MulOneClass M] (self : Submonoid M)
Goal: 1 ∈ self.carrier