ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Padic.mk_eq
theorem mk_eq {f g : PadicSeq p} : mk f = mk g ↔ f ≈ g 
Arguments: (p : ℕ) [Fact (Nat.Prime p)] {f g : PadicSeq p}
Goal: Padic.mk f = Padic.mk g ↔ f ≈ g
-- Padic.const_equiv
theorem const_equiv {q r : ℚ} : const (padicNorm p) q ≈ const (padicNorm p) r ↔ q = r 
Arguments: (p : ℕ) [Fact (Nat.Prime p)] {q r : ℚ}
Goal: CauSeq.const (padicNorm p) q ≈ CauSeq.const (padicNorm p) r ↔ q = r
-- Padic.coe_inj
@[norm_cast]
theorem coe_inj {q r : ℚ} : (↑q : ℚ_[p]) = ↑r ↔ q = r 
Arguments: (p : ℕ) [Fact (Nat.Prime p)] {q r : ℚ}
Goal: ↑q = ↑r ↔ q = r
-- Padic.coe_add
@[norm_cast]
theorem coe_add : ∀ {x y : ℚ}, (↑(x + y) : ℚ_[p]) = ↑x + ↑y 
Arguments: (p : ℕ) [Fact (Nat.Prime p)] {x y : ℚ}
Goal: ↑(x + y) = ↑x + ↑y
-- Padic.coe_neg
@[norm_cast]
theorem coe_neg : ∀ {x : ℚ}, (↑(-x) : ℚ_[p]) = -↑x 
Arguments: (p : ℕ) [Fact (Nat.Prime p)] {x : ℚ}
Goal: ↑(-x) = -↑x
-- Padic.coe_mul
@[norm_cast]
theorem coe_mul : ∀ {x y : ℚ}, (↑(x * y) : ℚ_[p]) = ↑x * ↑y 
Arguments: (p : ℕ) [Fact (Nat.Prime p)] {x y : ℚ}
Goal: ↑(x * y) = ↑x * ↑y
-- Padic.coe_sub
@[norm_cast]
theorem coe_sub : ∀ {x y : ℚ}, (↑(x - y) : ℚ_[p]) = ↑x - ↑y 
Arguments: (p : ℕ) [Fact (Nat.Prime p)] {x y : ℚ}
Goal: ↑(x - y) = ↑x - ↑y
-- Padic.coe_div
@[norm_cast]
theorem coe_div : ∀ {x y : ℚ}, (↑(x / y) : ℚ_[p]) = ↑x / ↑y 
Arguments: (p : ℕ) [Fact (Nat.Prime p)] {x y : ℚ}
Goal: ↑(x / y) = ↑x / ↑y
-- Padic.coe_one
@[norm_cast]
theorem coe_one : (↑(1 : ℚ) : ℚ_[p]) = 1 
Arguments: (p : ℕ) [Fact (Nat.Prime p)]
Goal: ↑1 = 1
-- Padic.coe_zero
@[norm_cast]
theorem coe_zero : (↑(0 : ℚ) : ℚ_[p]) = 0 
Arguments: (p : ℕ) [Fact (Nat.Prime p)]
Goal: ↑0 = 0
-- padicNormE.defn
theorem defn (f : PadicSeq p) {ε : ℚ} (hε : 0 < ε) :
    ∃ N, ∀ i ≥ N, padicNormE (Padic.mk f - f i : ℚ_[p]) < ε 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] (f : PadicSeq p) {ε : ℚ} (hε : 0 < ε)
Goal: ∃ N, ∀ i ≥ N, padicNormE (Padic.mk f - ↑(↑f i)) < ε
-- padicNormE.nonarchimedean'
theorem nonarchimedean' (q r : ℚ_[p]) :
    padicNormE (q + r : ℚ_[p]) ≤ max (padicNormE q) (padicNormE r) 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] (q r : ℚ_[p])
Goal: padicNormE (q + r) ≤ max (padicNormE q) (padicNormE r)
-- padicNormE.add_eq_max_of_ne'
theorem add_eq_max_of_ne' {q r : ℚ_[p]} :
    padicNormE q ≠ padicNormE r → padicNormE (q + r : ℚ_[p]) = max (padicNormE q) (padicNormE r) 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {q r : ℚ_[p]}
Goal: padicNormE q ≠ padicNormE r → padicNormE (q + r) = max (padicNormE q) (padicNormE r)
-- padicNormE.eq_padic_norm'
@[simp]
theorem eq_padic_norm' (q : ℚ) : padicNormE (q : ℚ_[p]) = padicNorm p q 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] (q : ℚ)
Goal: padicNormE ↑q = padicNorm p q
-- padicNormE.image'
protected theorem image' {q : ℚ_[p]} : q ≠ 0 → ∃ n : ℤ, padicNormE q = (p : ℚ) ^ (-n) 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {q : ℚ_[p]}
Goal: q ≠ 0 → ∃ n, padicNormE q = ↑p ^ (-n)
-- Padic.rat_dense'
theorem rat_dense' (q : ℚ_[p]) {ε : ℚ} (hε : 0 < ε) : ∃ r : ℚ, padicNormE (q - r : ℚ_[p]) < ε 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] (q : ℚ_[p]) {ε : ℚ} (hε : 0 < ε)
Goal: ∃ r, padicNormE (q - ↑r) < ε
-- _private.Mathlib.NumberTheory.Padics.PadicNumbers.0.Padic.div_nat_pos
private theorem div_nat_pos (n : ℕ) : 0 < 1 / (n + 1 : ℚ) 
Arguments: (n : ℕ)
Goal: 0 < 1 / (↑n + 1)
-- Padic.exi_rat_seq_conv
theorem exi_rat_seq_conv {ε : ℚ} (hε : 0 < ε) :
    ∃ N, ∀ i ≥ N, padicNormE (f i - (limSeq f i : ℚ_[p]) : ℚ_[p]) < ε 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] (f : CauSeq ℚ_[p] ⇑padicNormE) {ε : ℚ} (hε : 0 < ε)
Goal: ∃ N, ∀ i ≥ N, padicNormE (↑f i - ↑(Padic.limSeq f i)) < ε
-- Padic.exi_rat_seq_conv_cauchy
theorem exi_rat_seq_conv_cauchy : IsCauSeq (padicNorm p) (limSeq f) 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] (f : CauSeq ℚ_[p] ⇑padicNormE)
Goal: IsCauSeq (padicNorm p) (Padic.limSeq f)
-- Padic.complete'
theorem complete' : ∃ q : ℚ_[p], ∀ ε > 0, ∃ N, ∀ i ≥ N, padicNormE (q - f i : ℚ_[p]) < ε 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] (f : CauSeq ℚ_[p] ⇑padicNormE)
Goal: ∃ q, ∀ ε > 0, ∃ N, ∀ i ≥ N, padicNormE (q - ↑f i) < ε
-- Padic.complete''
theorem complete'' : ∃ q : ℚ_[p], ∀ ε > 0, ∃ N, ∀ i ≥ N, padicNormE (f i - q : ℚ_[p]) < ε 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] (f : CauSeq ℚ_[p] ⇑padicNormE)
Goal: ∃ q, ∀ ε > 0, ∃ N, ∀ i ≥ N, padicNormE (↑f i - q) < ε
-- Padic.rat_dense
theorem rat_dense (q : ℚ_[p]) {ε : ℝ} (hε : 0 < ε) : ∃ r : ℚ, ‖q - r‖ < ε 
Arguments: (p : ℕ) [Fact (Nat.Prime p)] (q : ℚ_[p]) {ε : ℝ} (hε : 0 < ε)
Goal: ∃ r, ‖q - ↑r‖ < ε
-- padicNormE.mul
@[simp (high)]
protected theorem mul (q r : ℚ_[p]) : ‖q * r‖ = ‖q‖ * ‖r‖ 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (q r : ℚ_[p])
Goal: ‖q * r‖ = ‖q‖ * ‖r‖
-- padicNormE.is_norm
protected theorem is_norm (q : ℚ_[p]) : ↑(padicNormE q) = ‖q‖ 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (q : ℚ_[p])
Goal: ↑(padicNormE q) = ‖q‖
-- padicNormE.nonarchimedean
theorem nonarchimedean (q r : ℚ_[p]) : ‖q + r‖ ≤ max ‖q‖ ‖r‖ 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (q r : ℚ_[p])
Goal: ‖q + r‖ ≤ max ‖q‖ ‖r‖
-- padicNormE.add_eq_max_of_ne
theorem add_eq_max_of_ne {q r : ℚ_[p]} (h : ‖q‖ ≠ ‖r‖) : ‖q + r‖ = max ‖q‖ ‖r‖ 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {q r : ℚ_[p]} (h : ‖q‖ ≠ ‖r‖)
Goal: ‖q + r‖ = max ‖q‖ ‖r‖
-- padicNormE.eq_padicNorm
@[simp]
theorem eq_padicNorm (q : ℚ) : ‖(q : ℚ_[p])‖ = padicNorm p q 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (q : ℚ)
Goal: ‖↑q‖ = ↑(padicNorm p q)
-- padicNormE.norm_p
@[simp]
theorem norm_p : ‖(p : ℚ_[p])‖ = (p : ℝ)⁻¹ 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)]
Goal: ‖↑p‖ = (↑p)⁻¹
-- padicNormE.norm_p_lt_one
theorem norm_p_lt_one : ‖(p : ℚ_[p])‖ < 1 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)]
Goal: ‖↑p‖ < 1
-- padicNormE.norm_p_zpow
@[simp (high)]
theorem norm_p_zpow (n : ℤ) : ‖(p : ℚ_[p]) ^ n‖ = (p : ℝ) ^ (-n) 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (n : ℤ)
Goal: ‖↑p ^ n‖ = ↑p ^ (-n)
-- padicNormE.norm_p_pow
@[simp (high)]
theorem norm_p_pow (n : ℕ) : ‖(p : ℚ_[p]) ^ n‖ = (p : ℝ) ^ (-n : ℤ) 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (n : ℕ)
Goal: ‖↑p ^ n‖ = ↑p ^ (-↑n)
-- padicNormE.image
protected theorem image {q : ℚ_[p]} : q ≠ 0 → ∃ n : ℤ, ‖q‖ = ↑((p : ℚ) ^ (-n)) 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {q : ℚ_[p]}
Goal: q ≠ 0 → ∃ n, ‖q‖ = ↑(↑p ^ (-n))
-- padicNormE.is_rat
protected theorem is_rat (q : ℚ_[p]) : ∃ q' : ℚ, ‖q‖ = q' 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (q : ℚ_[p])
Goal: ∃ q', ‖q‖ = ↑q'
-- padicNormE.eq_ratNorm
theorem eq_ratNorm (q : ℚ_[p]) : ‖q‖ = ratNorm q 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (q : ℚ_[p])
Goal: ‖q‖ = ↑(padicNormE.ratNorm q)
-- padicNormE.norm_rat_le_one
theorem norm_rat_le_one : ∀ {q : ℚ} (_ : ¬p ∣ q.den), ‖(q : ℚ_[p])‖ ≤ 1
  
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {q : ℚ}
Goal: ¬p ∣ q.den → ‖↑q‖ ≤ 1
-- padicNormE.norm_int_le_one
theorem norm_int_le_one (z : ℤ) : ‖(z : ℚ_[p])‖ ≤ 1 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (z : ℤ)
Goal: ‖↑z‖ ≤ 1
-- padicNormE.norm_int_lt_one_iff_dvd
theorem norm_int_lt_one_iff_dvd (k : ℤ) : ‖(k : ℚ_[p])‖ < 1 ↔ ↑p ∣ k 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (k : ℤ)
Goal: ‖↑k‖ < 1 ↔ ↑p ∣ k
-- padicNormE.norm_int_le_pow_iff_dvd
theorem norm_int_le_pow_iff_dvd (k : ℤ) (n : ℕ) :
    ‖(k : ℚ_[p])‖ ≤ (p : ℝ) ^ (-n : ℤ) ↔ (p ^ n : ℤ) ∣ k 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (k : ℤ) (n : ℕ)
Goal: ‖↑k‖ ≤ ↑p ^ (-↑n) ↔ ↑p ^ n ∣ k
-- padicNormE.eq_of_norm_add_lt_right
theorem eq_of_norm_add_lt_right {z1 z2 : ℚ_[p]} (h : ‖z1 + z2‖ < ‖z2‖) : ‖z1‖ = ‖z2‖ 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {z1 z2 : ℚ_[p]} (h : ‖z1 + z2‖ < ‖z2‖)
Goal: ‖z1‖ = ‖z2‖
-- padicNormE.eq_of_norm_add_lt_left
theorem eq_of_norm_add_lt_left {z1 z2 : ℚ_[p]} (h : ‖z1 + z2‖ < ‖z1‖) : ‖z1‖ = ‖z2‖ 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {z1 z2 : ℚ_[p]} (h : ‖z1 + z2‖ < ‖z1‖)
Goal: ‖z1‖ = ‖z2‖
-- Padic.padicNormE_lim_le
theorem padicNormE_lim_le {f : CauSeq ℚ_[p] norm} {a : ℝ} (ha : 0 < a) (hf : ∀ i, ‖f i‖ ≤ a) :
    ‖f.lim‖ ≤ a 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {f : CauSeq ℚ_[p] norm} {a : ℝ} (ha : 0 < a) (hf : ∀ (i : ℕ), ‖↑f i‖ ≤ a)
Goal: ‖f.lim‖ ≤ a
-- Padic.valuation_zero
@[simp]
theorem valuation_zero : valuation (0 : ℚ_[p]) = 0 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)]
Goal: Padic.valuation 0 = 0
-- Padic.valuation_one
@[simp]
theorem valuation_one : valuation (1 : ℚ_[p]) = 0 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)]
Goal: Padic.valuation 1 = 0
-- Padic.norm_eq_pow_val
theorem norm_eq_pow_val {x : ℚ_[p]} : x ≠ 0 → ‖x‖ = (p : ℝ) ^ (-x.valuation) 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {x : ℚ_[p]}
Goal: x ≠ 0 → ‖x‖ = ↑p ^ (-x.valuation)
-- Padic.valuation_p
@[simp]
theorem valuation_p : valuation (p : ℚ_[p]) = 1 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)]
Goal: (↑p).valuation = 1
-- Padic.valuation_map_add
theorem valuation_map_add {x y : ℚ_[p]} (hxy : x + y ≠ 0) :
    min (valuation x) (valuation y) ≤ valuation (x + y : ℚ_[p]) 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {x y : ℚ_[p]} (hxy : x + y ≠ 0)
Goal: min x.valuation y.valuation ≤ (x + y).valuation
-- Padic.valuation_map_mul
@[simp]
theorem valuation_map_mul {x y : ℚ_[p]} (hx : x ≠ 0) (hy : y ≠ 0) :
    valuation (x * y : ℚ_[p]) = valuation x + valuation y 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {x y : ℚ_[p]} (hx : x ≠ 0) (hy : y ≠ 0)
Goal: (x * y).valuation = x.valuation + y.valuation
-- Padic.AddValuation.map_zero
@[simp]
theorem AddValuation.map_zero : addValuationDef (0 : ℚ_[p]) = ⊤ 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)]
Goal: Padic.addValuationDef 0 = ⊤
-- Padic.AddValuation.map_one
@[simp]
theorem AddValuation.map_one : addValuationDef (1 : ℚ_[p]) = 0 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)]
Goal: Padic.addValuationDef 1 = 0
-- Padic.AddValuation.map_mul
theorem AddValuation.map_mul (x y : ℚ_[p]) :
    addValuationDef (x * y : ℚ_[p]) = addValuationDef x + addValuationDef y 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (x y : ℚ_[p])
Goal: (x * y).addValuationDef = x.addValuationDef + y.addValuationDef
-- Padic.AddValuation.map_add
theorem AddValuation.map_add (x y : ℚ_[p]) :
    min (addValuationDef x) (addValuationDef y) ≤ addValuationDef (x + y : ℚ_[p]) 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (x y : ℚ_[p])
Goal: min x.addValuationDef y.addValuationDef ≤ (x + y).addValuationDef
-- Padic.addValuation.apply
@[simp]
theorem addValuation.apply {x : ℚ_[p]} (hx : x ≠ 0) :
    Padic.addValuation x = (x.valuation : WithTop ℤ) 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {x : ℚ_[p]} (hx : x ≠ 0)
Goal: Padic.addValuation x = ↑x.valuation
-- Padic.norm_le_pow_iff_norm_lt_pow_add_one
theorem norm_le_pow_iff_norm_lt_pow_add_one (x : ℚ_[p]) (n : ℤ) :
    ‖x‖ ≤ (p : ℝ) ^ n ↔ ‖x‖ < (p : ℝ) ^ (n + 1) 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (x : ℚ_[p]) (n : ℤ)
Goal: ‖x‖ ≤ ↑p ^ n ↔ ‖x‖ < ↑p ^ (n + 1)
-- Padic.norm_lt_pow_iff_norm_le_pow_sub_one
theorem norm_lt_pow_iff_norm_le_pow_sub_one (x : ℚ_[p]) (n : ℤ) :
    ‖x‖ < (p : ℝ) ^ n ↔ ‖x‖ ≤ (p : ℝ) ^ (n - 1) 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (x : ℚ_[p]) (n : ℤ)
Goal: ‖x‖ < ↑p ^ n ↔ ‖x‖ ≤ ↑p ^ (n - 1)
-- Padic.norm_le_one_iff_val_nonneg
theorem norm_le_one_iff_val_nonneg (x : ℚ_[p]) : ‖x‖ ≤ 1 ↔ 0 ≤ x.valuation 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (x : ℚ_[p])
Goal: ‖x‖ ≤ 1 ↔ 0 ≤ x.valuation
-- _private.Mathlib.NumberTheory.SiegelsLemma.0.Int.Matrix.image_T_subset_S
private lemma image_T_subset_S (v) (hv : v ∈ T) : A *ᵥ v ∈ S 
Arguments: {α : Type u_1} {β : Type u_2} [Fintype α] [Fintype β] (A : Matrix α β ℤ) [DecidableEq α] [DecidableEq β] (v : β → ℤ) (hv :
  v ∈
    Finset.Icc 0 fun x =>
      ↑⌊(↑(Fintype.card β) * max 1 ‖A‖) ^ (↑(Fintype.card α) / (↑(Fintype.card β) - ↑(Fintype.card α)))⌋₊)
Goal: A *ᵥ v ∈
  Finset.Icc
    (fun i =>
      ∑ j : β,
        ↑⌊(↑(Fintype.card β) * max 1 ‖A‖) ^ (↑(Fintype.card α) / (↑(Fintype.card β) - ↑(Fintype.card α)))⌋₊ * -(A i j)⁻)
    fun i =>
    ∑ j : β,
      ↑⌊(↑(Fintype.card β) * max 1 ‖A‖) ^ (↑(Fintype.card α) / (↑(Fintype.card β) - ↑(Fintype.card α)))⌋₊ * (A i j)⁺
-- _private.Mathlib.NumberTheory.SiegelsLemma.0.Int.Matrix.card_T_eq
private lemma card_T_eq : (T).card = (B + 1) ^ n 
Arguments: {α : Type u_1} {β : Type u_2} [Fintype α] [Fintype β] (A : Matrix α β ℤ) [DecidableEq β]
Goal: (Finset.Icc 0 fun x =>
      ↑⌊(↑(Fintype.card β) * max 1 ‖A‖) ^ (↑(Fintype.card α) / (↑(Fintype.card β) - ↑(Fintype.card α)))⌋₊).card =
  (⌊(↑(Fintype.card β) * max 1 ‖A‖) ^ (↑(Fintype.card α) / (↑(Fintype.card β) - ↑(Fintype.card α)))⌋₊ + 1) ^
    Fintype.card β
-- _private.Mathlib.NumberTheory.SiegelsLemma.0.Int.Matrix.N_le_P_add_one
private lemma N_le_P_add_one (i : α) : N i ≤ P i + 1 
Arguments: {α : Type u_1} {β : Type u_2} [Fintype α] [Fintype β] (A : Matrix α β ℤ) (i : α)
Goal: (fun i =>
      ∑ j : β,
        ↑⌊(↑(Fintype.card β) * max 1 ‖A‖) ^ (↑(Fintype.card α) / (↑(Fintype.card β) - ↑(Fintype.card α)))⌋₊ * -(A i j)⁻)
    i ≤
  (fun i =>
        ∑ j : β,
          ↑⌊(↑(Fintype.card β) * max 1 ‖A‖) ^ (↑(Fintype.card α) / (↑(Fintype.card β) - ↑(Fintype.card α)))⌋₊ *
            (A i j)⁺)
      i +
    1
-- _private.Mathlib.NumberTheory.SiegelsLemma.0.Int.Matrix.card_S_eq
private lemma card_S_eq : (Finset.Icc N P).card = ∏ i : α, (P i - N i + 1) 
Arguments: {α : Type u_1} {β : Type u_2} [Fintype α] [Fintype β] (A : Matrix α β ℤ) [DecidableEq α]
Goal: ↑(Finset.Icc
        (fun i =>
          ∑ j : β,
            ↑⌊(↑(Fintype.card β) * max 1 ‖A‖) ^ (↑(Fintype.card α) / (↑(Fintype.card β) - ↑(Fintype.card α)))⌋₊ *
              -(A i j)⁻)
        fun i =>
        ∑ j : β,
          ↑⌊(↑(Fintype.card β) * max 1 ‖A‖) ^ (↑(Fintype.card α) / (↑(Fintype.card β) - ↑(Fintype.card α)))⌋₊ *
            (A i j)⁺).card =
  ∏ i : α,
    ((fun i =>
            ∑ j : β,
              ↑⌊(↑(Fintype.card β) * max 1 ‖A‖) ^ (↑(Fintype.card α) / (↑(Fintype.card β) - ↑(Fintype.card α)))⌋₊ *
                (A i j)⁺)
          i -
        (fun i =>
            ∑ j : β,
              ↑⌊(↑(Fintype.card β) * max 1 ‖A‖) ^ (↑(Fintype.card α) / (↑(Fintype.card β) - ↑(Fintype.card α)))⌋₊ *
                -(A i j)⁻)
          i +
      1)
-- Int.Matrix.one_le_norm_A_of_ne_zero
lemma one_le_norm_A_of_ne_zero (hA : A ≠ 0) : 1 ≤ ‖A‖ 
Arguments: {α : Type u_1} {β : Type u_2} [Fintype α] [Fintype β] (A : Matrix α β ℤ) (hA : A ≠ 0)
Goal: 1 ≤ ‖A‖
-- _private.Mathlib.NumberTheory.SiegelsLemma.0.Int.Matrix.card_S_lt_card_T
private lemma card_S_lt_card_T : (S).card < (T).card 
Arguments: {α : Type u_1} {β : Type u_2} [Fintype α] [Fintype β] (A : Matrix α β ℤ) (hn : Fintype.card α < Fintype.card β) (hm : 0 < Fintype.card α) [DecidableEq α] [DecidableEq β]
Goal: (Finset.Icc
      (fun i =>
        ∑ j : β,
          ↑⌊(↑(Fintype.card β) * max 1 ‖A‖) ^ (↑(Fintype.card α) / (↑(Fintype.card β) - ↑(Fintype.card α)))⌋₊ *
            -(A i j)⁻)
      fun i =>
      ∑ j : β,
        ↑⌊(↑(Fintype.card β) * max 1 ‖A‖) ^ (↑(Fintype.card α) / (↑(Fintype.card β) - ↑(Fintype.card α)))⌋₊ *
          (A i j)⁺).card <
  (Finset.Icc 0 fun x =>
      ↑⌊(↑(Fintype.card β) * max 1 ‖A‖) ^ (↑(Fintype.card α) / (↑(Fintype.card β) - ↑(Fintype.card α)))⌋₊).card
-- Int.Matrix.exists_ne_zero_int_vec_norm_le
theorem exists_ne_zero_int_vec_norm_le : ∃ t : β → ℤ, t ≠ 0 ∧
    A *ᵥ t = 0 ∧ ‖t‖ ≤ (n * max 1 ‖A‖) ^ ((m : ℝ) / (n - m)) 
Arguments: {α : Type u_1} {β : Type u_2} [Fintype α] [Fintype β] (A : Matrix α β ℤ) (hn : Fintype.card α < Fintype.card β) (hm : 0 < Fintype.card α)
Goal: ∃ t,
  t ≠ 0 ∧
    A *ᵥ t = 0 ∧ ‖t‖ ≤ (↑(Fintype.card β) * max 1 ‖A‖) ^ (↑(Fintype.card α) / (↑(Fintype.card β) - ↑(Fintype.card α)))
-- Int.Matrix.exists_ne_zero_int_vec_norm_le'
theorem exists_ne_zero_int_vec_norm_le' (hA : A ≠ 0) : ∃ t : β → ℤ, t ≠ 0 ∧
    A *ᵥ t = 0 ∧ ‖t‖ ≤ (n * ‖A‖) ^ ((m : ℝ) / (n - m)) 
Arguments: {α : Type u_1} {β : Type u_2} [Fintype α] [Fintype β] (A : Matrix α β ℤ) (hn : Fintype.card α < Fintype.card β) (hm : 0 < Fintype.card α) (hA : A ≠ 0)
Goal: ∃ t,
  t ≠ 0 ∧ A *ᵥ t = 0 ∧ ‖t‖ ≤ (↑(Fintype.card β) * ‖A‖) ^ (↑(Fintype.card α) / (↑(Fintype.card β) - ↑(Fintype.card α)))
-- NumberField.mixedEmbedding.convexBodyLT_mem
theorem convexBodyLT_mem {x : K} :
    mixedEmbedding K x ∈ (convexBodyLT K f) ↔ ∀ w : InfinitePlace K, w x < f w 
Arguments: (K : Type u_1) [Field K] (f : NumberField.InfinitePlace K → NNReal) {x : K}
Goal: (NumberField.mixedEmbedding K) x ∈ NumberField.mixedEmbedding.convexBodyLT K f ↔
  ∀ (w : NumberField.InfinitePlace K), w x < ↑(f w)
-- NumberField.mixedEmbedding.convexBodyLT_neg_mem
theorem convexBodyLT_neg_mem (x : E K) (hx : x ∈ (convexBodyLT K f)) :
    -x ∈ (convexBodyLT K f) 
Arguments: (K : Type u_1) [Field K] (f : NumberField.InfinitePlace K → NNReal) (x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)) (hx : x ∈ NumberField.mixedEmbedding.convexBodyLT K f)
Goal: -x ∈ NumberField.mixedEmbedding.convexBodyLT K f
-- NumberField.mixedEmbedding.convexBodyLT_convex
theorem convexBodyLT_convex : Convex ℝ (convexBodyLT K f) 
Arguments: (K : Type u_1) [Field K] (f : NumberField.InfinitePlace K → NNReal)
Goal: Convex ℝ (NumberField.mixedEmbedding.convexBodyLT K f)
-- NumberField.mixedEmbedding.convexBodyLTFactor_ne_zero
theorem convexBodyLTFactor_ne_zero : convexBodyLTFactor K ≠ 0 
Arguments: (K : Type u_1) [Field K] [NumberField K]
Goal: NumberField.mixedEmbedding.convexBodyLTFactor K ≠ 0
-- NumberField.mixedEmbedding.one_le_convexBodyLTFactor
theorem one_le_convexBodyLTFactor : 1 ≤ convexBodyLTFactor K 
Arguments: (K : Type u_1) [Field K] [NumberField K]
Goal: 1 ≤ NumberField.mixedEmbedding.convexBodyLTFactor K
-- NumberField.mixedEmbedding.convexBodyLT_volume
theorem convexBodyLT_volume :
    volume (convexBodyLT K f) = (convexBodyLTFactor K) * ∏ w, (f w) ^ (mult w) 
Arguments: (K : Type u_1) [Field K] (f : NumberField.InfinitePlace K → NNReal) [NumberField K]
Goal: MeasureTheory.volume (NumberField.mixedEmbedding.convexBodyLT K f) =
  ↑(NumberField.mixedEmbedding.convexBodyLTFactor K) * ↑(∏ w : NumberField.InfinitePlace K, f w ^ w.mult)
-- NumberField.mixedEmbedding.adjust_f
theorem adjust_f {w₁ : InfinitePlace K} (B : ℝ≥0) (hf : ∀ w, w ≠ w₁ → f w ≠ 0) :
    ∃ g : InfinitePlace K → ℝ≥0, (∀ w, w ≠ w₁ → g w = f w) ∧ ∏ w, (g w) ^ mult w = B 
Arguments: (K : Type u_1) [Field K] {f : NumberField.InfinitePlace K → NNReal} [NumberField K] {w₁ : NumberField.InfinitePlace K} (B : NNReal) (hf : ∀ (w : NumberField.InfinitePlace K), w ≠ w₁ → f w ≠ 0)
Goal: ∃ g, (∀ (w : NumberField.InfinitePlace K), w ≠ w₁ → g w = f w) ∧ ∏ w : NumberField.InfinitePlace K, g w ^ w.mult = B
-- NumberField.mixedEmbedding.convexBodyLT'_mem
theorem convexBodyLT'_mem {x : K} :
    mixedEmbedding K x ∈ convexBodyLT' K f w₀ ↔
      (∀ w : InfinitePlace K, w ≠ w₀ → w x < f w) ∧
      |(w₀.val.embedding x).re| < 1 ∧ |(w₀.val.embedding x).im| < (f w₀ : ℝ) ^ 2 
Arguments: (K : Type u_1) [Field K] (f : NumberField.InfinitePlace K → NNReal) (w₀ : { w // w.IsComplex }) {x : K}
Goal: (NumberField.mixedEmbedding K) x ∈ NumberField.mixedEmbedding.convexBodyLT' K f w₀ ↔
  (∀ (w : NumberField.InfinitePlace K), w ≠ ↑w₀ → w x < ↑(f w)) ∧
    |((↑w₀).embedding x).re| < 1 ∧ |((↑w₀).embedding x).im| < ↑(f ↑w₀) ^ 2
-- NumberField.mixedEmbedding.convexBodyLT'_neg_mem
theorem convexBodyLT'_neg_mem (x : E K) (hx : x ∈ convexBodyLT' K f w₀) :
    -x ∈ convexBodyLT' K f w₀ 
Arguments: (K : Type u_1) [Field K] (f : NumberField.InfinitePlace K → NNReal) (w₀ : { w // w.IsComplex }) (x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)) (hx : x ∈ NumberField.mixedEmbedding.convexBodyLT' K f w₀)
Goal: -x ∈ NumberField.mixedEmbedding.convexBodyLT' K f w₀
-- NumberField.mixedEmbedding.convexBodyLT'_convex
theorem convexBodyLT'_convex : Convex ℝ (convexBodyLT' K f w₀) 
Arguments: (K : Type u_1) [Field K] (f : NumberField.InfinitePlace K → NNReal) (w₀ : { w // w.IsComplex })
Goal: Convex ℝ (NumberField.mixedEmbedding.convexBodyLT' K f w₀)
-- NumberField.mixedEmbedding.convexBodyLT'Factor_ne_zero
theorem convexBodyLT'Factor_ne_zero : convexBodyLT'Factor K ≠ 0 
Arguments: (K : Type u_1) [Field K] [NumberField K]
Goal: NumberField.mixedEmbedding.convexBodyLT'Factor K ≠ 0
-- NumberField.mixedEmbedding.one_le_convexBodyLT'Factor
theorem one_le_convexBodyLT'Factor : 1 ≤ convexBodyLT'Factor K 
Arguments: (K : Type u_1) [Field K] [NumberField K]
Goal: 1 ≤ NumberField.mixedEmbedding.convexBodyLT'Factor K
-- NumberField.mixedEmbedding.convexBodyLT'_volume
theorem convexBodyLT'_volume :
    volume (convexBodyLT' K f w₀) = convexBodyLT'Factor K * ∏ w, (f w) ^ (mult w) 
Arguments: (K : Type u_1) [Field K] (f : NumberField.InfinitePlace K → NNReal) (w₀ : { w // w.IsComplex }) [NumberField K]
Goal: MeasureTheory.volume (NumberField.mixedEmbedding.convexBodyLT' K f w₀) =
  ↑(NumberField.mixedEmbedding.convexBodyLT'Factor K) * ↑(∏ w : NumberField.InfinitePlace K, f w ^ w.mult)
-- NumberField.mixedEmbedding.convexBodySumFun_apply
theorem convexBodySumFun_apply (x : E K) :
    convexBodySumFun x = ∑ w,  mult w * normAtPlace w x 
Arguments: {K : Type u_1} [Field K] [NumberField K] (x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ))
Goal: NumberField.mixedEmbedding.convexBodySumFun x =
  ∑ w : NumberField.InfinitePlace K, ↑w.mult * (NumberField.mixedEmbedding.normAtPlace w) x
-- NumberField.mixedEmbedding.convexBodySumFun_apply'
theorem convexBodySumFun_apply' (x : E K) :
    convexBodySumFun x = ∑ w, ‖x.1 w‖ + 2 * ∑ w, ‖x.2 w‖ 
Arguments: {K : Type u_1} [Field K] [NumberField K] (x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ))
Goal: NumberField.mixedEmbedding.convexBodySumFun x =
  ∑ w : { w // w.IsReal }, ‖x.1 w‖ + 2 * ∑ w : { w // w.IsComplex }, ‖x.2 w‖
-- NumberField.mixedEmbedding.convexBodySumFun_nonneg
theorem convexBodySumFun_nonneg (x : E K) :
    0 ≤ convexBodySumFun x 
Arguments: {K : Type u_1} [Field K] [NumberField K] (x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ))
Goal: 0 ≤ NumberField.mixedEmbedding.convexBodySumFun x
-- NumberField.mixedEmbedding.convexBodySumFun_neg
theorem convexBodySumFun_neg (x : E K) :
    convexBodySumFun (- x) = convexBodySumFun x 
Arguments: {K : Type u_1} [Field K] [NumberField K] (x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ))
Goal: NumberField.mixedEmbedding.convexBodySumFun (-x) = NumberField.mixedEmbedding.convexBodySumFun x
-- NumberField.mixedEmbedding.convexBodySumFun_add_le
theorem convexBodySumFun_add_le (x y : E K) :
    convexBodySumFun (x + y) ≤ convexBodySumFun x + convexBodySumFun y 
Arguments: {K : Type u_1} [Field K] [NumberField K] (x y : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ))
Goal: NumberField.mixedEmbedding.convexBodySumFun (x + y) ≤
  NumberField.mixedEmbedding.convexBodySumFun x + NumberField.mixedEmbedding.convexBodySumFun y
-- NumberField.mixedEmbedding.convexBodySumFun_smul
theorem convexBodySumFun_smul (c : ℝ) (x : E K) :
    convexBodySumFun (c • x) = |c| * convexBodySumFun x 
Arguments: {K : Type u_1} [Field K] [NumberField K] (c : ℝ) (x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ))
Goal: NumberField.mixedEmbedding.convexBodySumFun (c • x) = |c| * NumberField.mixedEmbedding.convexBodySumFun x
-- NumberField.mixedEmbedding.convexBodySumFun_eq_zero_iff
theorem convexBodySumFun_eq_zero_iff (x : E K) :
    convexBodySumFun x = 0 ↔ x = 0 
Arguments: {K : Type u_1} [Field K] [NumberField K] (x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ))
Goal: NumberField.mixedEmbedding.convexBodySumFun x = 0 ↔ x = 0
-- NumberField.mixedEmbedding.norm_le_convexBodySumFun
theorem norm_le_convexBodySumFun (x : E K) : ‖x‖ ≤ convexBodySumFun x 
Arguments: {K : Type u_1} [Field K] [NumberField K] (x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ))
Goal: ‖x‖ ≤ NumberField.mixedEmbedding.convexBodySumFun x
-- NumberField.mixedEmbedding.convexBodySumFun_continuous
theorem convexBodySumFun_continuous :
    Continuous (convexBodySumFun : (E K) → ℝ) 
Arguments: (K : Type u_1) [Field K] [NumberField K]
Goal: Continuous NumberField.mixedEmbedding.convexBodySumFun
-- NumberField.mixedEmbedding.convexBodySum_volume_eq_zero_of_le_zero
theorem convexBodySum_volume_eq_zero_of_le_zero {B} (hB : B ≤ 0) :
    volume (convexBodySum K B) = 0 
Arguments: (K : Type u_1) [Field K] [NumberField K] {B : ℝ} (hB : B ≤ 0)
Goal: MeasureTheory.volume (NumberField.mixedEmbedding.convexBodySum K B) = 0