ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- NumberField.mixedEmbedding.convexBodySum_mem
theorem convexBodySum_mem {x : K} :
    mixedEmbedding K x ∈ (convexBodySum K B) ↔
      ∑ w : InfinitePlace K, (mult w) * w.val x ≤ B 
Arguments: (K : Type u_1) [Field K] [NumberField K] (B : ℝ) {x : K}
Goal: (NumberField.mixedEmbedding K) x ∈ NumberField.mixedEmbedding.convexBodySum K B ↔
  ∑ w : NumberField.InfinitePlace K, ↑w.mult * ↑w x ≤ B
-- NumberField.mixedEmbedding.convexBodySum_neg_mem
theorem convexBodySum_neg_mem {x : E K} (hx : x ∈ (convexBodySum K B)) :
    -x ∈ (convexBodySum K B) 
Arguments: (K : Type u_1) [Field K] [NumberField K] (B : ℝ) {x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)} (hx : x ∈ NumberField.mixedEmbedding.convexBodySum K B)
Goal: -x ∈ NumberField.mixedEmbedding.convexBodySum K B
-- NumberField.mixedEmbedding.convexBodySum_convex
theorem convexBodySum_convex : Convex ℝ (convexBodySum K B) 
Arguments: (K : Type u_1) [Field K] [NumberField K] (B : ℝ)
Goal: Convex ℝ (NumberField.mixedEmbedding.convexBodySum K B)
-- NumberField.mixedEmbedding.convexBodySum_isBounded
theorem convexBodySum_isBounded : Bornology.IsBounded (convexBodySum K B) 
Arguments: (K : Type u_1) [Field K] [NumberField K] (B : ℝ)
Goal: Bornology.IsBounded (NumberField.mixedEmbedding.convexBodySum K B)
-- NumberField.mixedEmbedding.convexBodySum_compact
theorem convexBodySum_compact : IsCompact (convexBodySum K B) 
Arguments: (K : Type u_1) [Field K] [NumberField K] (B : ℝ)
Goal: IsCompact (NumberField.mixedEmbedding.convexBodySum K B)
-- NumberField.mixedEmbedding.convexBodySumFactor_ne_zero
theorem convexBodySumFactor_ne_zero : convexBodySumFactor K ≠ 0 
Arguments: (K : Type u_1) [Field K] [NumberField K]
Goal: NumberField.mixedEmbedding.convexBodySumFactor K ≠ 0
-- NumberField.mixedEmbedding.convexBodySum_volume
theorem convexBodySum_volume :
    volume (convexBodySum K B) = (convexBodySumFactor K) * (.ofReal B) ^ (finrank ℚ K) 
Arguments: (K : Type u_1) [Field K] [NumberField K] (B : ℝ)
Goal: MeasureTheory.volume (NumberField.mixedEmbedding.convexBodySum K B) =
  ↑(NumberField.mixedEmbedding.convexBodySumFactor K) * ENNReal.ofReal B ^ FiniteDimensional.finrank ℚ K
-- NumberField.mixedEmbedding.volume_fundamentalDomain_fractionalIdealLatticeBasis
theorem volume_fundamentalDomain_fractionalIdealLatticeBasis :
    volume (fundamentalDomain (fractionalIdealLatticeBasis K I)) =
      .ofReal (FractionalIdeal.absNorm I.1) *  volume (fundamentalDomain (latticeBasis K)) 
Arguments: (K : Type u_1) [Field K] [NumberField K] (I : (FractionalIdeal (nonZeroDivisors (NumberField.RingOfIntegers K)) K)ˣ)
Goal: MeasureTheory.volume (Zspan.fundamentalDomain (NumberField.mixedEmbedding.fractionalIdealLatticeBasis K I)) =
  ENNReal.ofReal ↑(FractionalIdeal.absNorm ↑I) *
    MeasureTheory.volume (Zspan.fundamentalDomain (NumberField.mixedEmbedding.latticeBasis K))
-- NumberField.mixedEmbedding.minkowskiBound_lt_top
theorem minkowskiBound_lt_top : minkowskiBound K I < ⊤ 
Arguments: (K : Type u_1) [Field K] [NumberField K] (I : (FractionalIdeal (nonZeroDivisors (NumberField.RingOfIntegers K)) K)ˣ)
Goal: NumberField.mixedEmbedding.minkowskiBound K I < ⊤
-- NumberField.mixedEmbedding.minkowskiBound_pos
theorem minkowskiBound_pos : 0 < minkowskiBound K I 
Arguments: (K : Type u_1) [Field K] [NumberField K] (I : (FractionalIdeal (nonZeroDivisors (NumberField.RingOfIntegers K)) K)ˣ)
Goal: 0 < NumberField.mixedEmbedding.minkowskiBound K I
-- NumberField.mixedEmbedding.exists_ne_zero_mem_ideal_lt
theorem exists_ne_zero_mem_ideal_lt (h : minkowskiBound K I < volume (convexBodyLT K f)) :
    ∃ a ∈ (I : FractionalIdeal (𝓞 K)⁰ K), a ≠ 0 ∧ ∀ w : InfinitePlace K, w a < f w 
Arguments: (K : Type u_1) [Field K] [NumberField K] {f : NumberField.InfinitePlace K → NNReal} (I : (FractionalIdeal (nonZeroDivisors (NumberField.RingOfIntegers K)) K)ˣ) (h : NumberField.mixedEmbedding.minkowskiBound K I < MeasureTheory.volume (NumberField.mixedEmbedding.convexBodyLT K f))
Goal: ∃ a ∈ ↑I, a ≠ 0 ∧ ∀ (w : NumberField.InfinitePlace K), w a < ↑(f w)
-- NumberField.mixedEmbedding.exists_ne_zero_mem_ideal_lt'
theorem exists_ne_zero_mem_ideal_lt' (w₀ : {w : InfinitePlace K // IsComplex w})
    (h : minkowskiBound K I < volume (convexBodyLT' K f w₀)) :
    ∃ a ∈ (I : FractionalIdeal (𝓞 K)⁰ K), a ≠ 0 ∧ (∀ w : InfinitePlace K, w ≠ w₀ → w a < f w) ∧
      |(w₀.val.embedding a).re| < 1 ∧ |(w₀.val.embedding a).im| < (f w₀ : ℝ) ^ 2 
Arguments: (K : Type u_1) [Field K] [NumberField K] {f : NumberField.InfinitePlace K → NNReal} (I : (FractionalIdeal (nonZeroDivisors (NumberField.RingOfIntegers K)) K)ˣ) (w₀ : { w // w.IsComplex }) (h :
  NumberField.mixedEmbedding.minkowskiBound K I <
    MeasureTheory.volume (NumberField.mixedEmbedding.convexBodyLT' K f w₀))
Goal: ∃ a ∈ ↑I,
  a ≠ 0 ∧
    (∀ (w : NumberField.InfinitePlace K), w ≠ ↑w₀ → w a < ↑(f w)) ∧
      |((↑w₀).embedding a).re| < 1 ∧ |((↑w₀).embedding a).im| < ↑(f ↑w₀) ^ 2
-- NumberField.mixedEmbedding.exists_ne_zero_mem_ringOfIntegers_lt
theorem exists_ne_zero_mem_ringOfIntegers_lt (h : minkowskiBound K ↑1 < volume (convexBodyLT K f)) :
    ∃ a : 𝓞 K, a ≠ 0 ∧ ∀ w : InfinitePlace K, w a < f w 
Arguments: (K : Type u_1) [Field K] [NumberField K] {f : NumberField.InfinitePlace K → NNReal} (h : NumberField.mixedEmbedding.minkowskiBound K 1 < MeasureTheory.volume (NumberField.mixedEmbedding.convexBodyLT K f))
Goal: ∃ a, a ≠ 0 ∧ ∀ (w : NumberField.InfinitePlace K), w ↑a < ↑(f w)
-- NumberField.mixedEmbedding.exists_ne_zero_mem_ringOfIntegers_lt'
theorem exists_ne_zero_mem_ringOfIntegers_lt' (w₀ : {w : InfinitePlace K // IsComplex w})
    (h : minkowskiBound K ↑1 < volume (convexBodyLT' K f w₀)) :
    ∃ a : 𝓞 K, a ≠ 0 ∧ (∀ w : InfinitePlace K, w ≠ w₀ → w a < f w) ∧
      |(w₀.val.embedding a).re| < 1 ∧ |(w₀.val.embedding a).im| < (f w₀ : ℝ) ^ 2 
Arguments: (K : Type u_1) [Field K] [NumberField K] {f : NumberField.InfinitePlace K → NNReal} (w₀ : { w // w.IsComplex }) (h :
  NumberField.mixedEmbedding.minkowskiBound K 1 <
    MeasureTheory.volume (NumberField.mixedEmbedding.convexBodyLT' K f w₀))
Goal: ∃ a,
  a ≠ 0 ∧
    (∀ (w : NumberField.InfinitePlace K), w ≠ ↑w₀ → w ↑a < ↑(f w)) ∧
      |((↑w₀).embedding ↑a).re| < 1 ∧ |((↑w₀).embedding ↑a).im| < ↑(f ↑w₀) ^ 2
-- NumberField.mixedEmbedding.exists_primitive_element_lt_of_isReal
theorem exists_primitive_element_lt_of_isReal {w₀ : InfinitePlace K} (hw₀ : IsReal w₀) {B : ℝ≥0}
    (hB : minkowskiBound K ↑1 < convexBodyLTFactor K * B) :
    ∃ a : 𝓞 K, ℚ⟮(a : K)⟯ = ⊤ ∧
      ∀ w : InfinitePlace K, w a < max B 1 
Arguments: (K : Type u_1) [Field K] [NumberField K] {w₀ : NumberField.InfinitePlace K} (hw₀ : w₀.IsReal) {B : NNReal} (hB : NumberField.mixedEmbedding.minkowskiBound K 1 < ↑(NumberField.mixedEmbedding.convexBodyLTFactor K) * ↑B)
Goal: ∃ a, ℚ⟮↑a⟯ = ⊤ ∧ ∀ (w : NumberField.InfinitePlace K), w ↑a < ↑(max B 1)
-- NumberField.mixedEmbedding.exists_primitive_element_lt_of_isComplex
theorem exists_primitive_element_lt_of_isComplex {w₀ : InfinitePlace K} (hw₀ : IsComplex w₀)
    {B : ℝ≥0} (hB : minkowskiBound K ↑1 < convexBodyLT'Factor K * B) :
    ∃ a : 𝓞 K, ℚ⟮(a : K)⟯ = ⊤ ∧
      ∀ w : InfinitePlace K, w a < Real.sqrt (1 + B ^ 2) 
Arguments: (K : Type u_1) [Field K] [NumberField K] {w₀ : NumberField.InfinitePlace K} (hw₀ : w₀.IsComplex) {B : NNReal} (hB : NumberField.mixedEmbedding.minkowskiBound K 1 < ↑(NumberField.mixedEmbedding.convexBodyLT'Factor K) * ↑B)
Goal: ∃ a, ℚ⟮↑a⟯ = ⊤ ∧ ∀ (w : NumberField.InfinitePlace K), w ↑a < √(1 + ↑B ^ 2)
-- NumberField.mixedEmbedding.exists_ne_zero_mem_ideal_of_norm_le
theorem exists_ne_zero_mem_ideal_of_norm_le {B : ℝ}
    (h : (minkowskiBound K I) ≤ volume (convexBodySum K B)) :
    ∃ a ∈ (I : FractionalIdeal (𝓞 K)⁰ K), a ≠ 0 ∧
      |Algebra.norm ℚ (a : K)| ≤ (B / finrank ℚ K) ^ finrank ℚ K 
Arguments: (K : Type u_1) [Field K] [NumberField K] (I : (FractionalIdeal (nonZeroDivisors (NumberField.RingOfIntegers K)) K)ˣ) {B : ℝ} (h :
  NumberField.mixedEmbedding.minkowskiBound K I ≤ MeasureTheory.volume (NumberField.mixedEmbedding.convexBodySum K B))
Goal: ∃ a ∈ ↑I, a ≠ 0 ∧ ↑|(Algebra.norm ℚ) a| ≤ (B / ↑(FiniteDimensional.finrank ℚ K)) ^ FiniteDimensional.finrank ℚ K
-- NumberField.mixedEmbedding.exists_ne_zero_mem_ringOfIntegers_of_norm_le
theorem exists_ne_zero_mem_ringOfIntegers_of_norm_le {B : ℝ}
    (h : (minkowskiBound K ↑1) ≤ volume (convexBodySum K B)) :
    ∃ a : 𝓞 K, a ≠ 0 ∧ |Algebra.norm ℚ (a : K)| ≤ (B / finrank ℚ K) ^ finrank ℚ K 
Arguments: (K : Type u_1) [Field K] [NumberField K] {B : ℝ} (h :
  NumberField.mixedEmbedding.minkowskiBound K 1 ≤ MeasureTheory.volume (NumberField.mixedEmbedding.convexBodySum K B))
Goal: ∃ a, a ≠ 0 ∧ ↑|(Algebra.norm ℚ) ↑a| ≤ (B / ↑(FiniteDimensional.finrank ℚ K)) ^ FiniteDimensional.finrank ℚ K
-- FDRep.Iso.conj_ρ
theorem Iso.conj_ρ {V W : FDRep k G} (i : V ≅ W) (g : G) :
    W.ρ g = (FDRep.isoToLinearEquiv i).conj (V.ρ g) 
Arguments: {k G : Type u} [Field k] [Monoid G] {V W : FDRep k G} (i : V ≅ W) (g : G)
Goal: W.ρ g = (FDRep.isoToLinearEquiv i).conj (V.ρ g)
-- FDRep.of_ρ
@[simps ρ]
def of {V : Type u} [AddCommGroup V] [Module k V] [FiniteDimensional k V]
    (ρ : Representation k G V) : FDRep k G 
Arguments: {k G : Type u} [Field k] [Monoid G] {V : Type u} [AddCommGroup V] [Module k V] [FiniteDimensional k V] (ρ : Representation k G V)
Goal: (FDRep.of ρ).ρ = ρ
-- FDRep.forget₂_ρ
theorem forget₂_ρ (V : FDRep k G) : ((forget₂ (FDRep k G) (Rep k G)).obj V).ρ = V.ρ 
Arguments: {k G : Type u} [Field k] [Monoid G] (V : FDRep k G)
Goal: ((CategoryTheory.forget₂ (FDRep k G) (Rep k G)).obj V).ρ = V.ρ
-- FDRep.finrank_hom_simple_simple
theorem finrank_hom_simple_simple [IsAlgClosed k] (V W : FDRep k G) [Simple V] [Simple W] :
    finrank k (V ⟶ W) = if Nonempty (V ≅ W) then 1 else 0 
Arguments: {k G : Type u} [Field k] [Monoid G] [IsAlgClosed k] (V W : FDRep k G) [CategoryTheory.Simple V] [CategoryTheory.Simple W]
Goal: FiniteDimensional.finrank k (V ⟶ W) = if Nonempty (V ≅ W) then 1 else 0
-- FDRep.dualTensorIsoLinHom_hom_hom
@[simp]
theorem dualTensorIsoLinHom_hom_hom : (dualTensorIsoLinHom ρV W).hom.hom = dualTensorHom k V W 
Arguments: {k G V : Type u} [Field k] [Group G] [AddCommGroup V] [Module k V] [FiniteDimensional k V] (ρV : Representation k G V) (W : FDRep k G)
Goal: (FDRep.dualTensorIsoLinHom ρV W).hom.hom = dualTensorHom k V (CoeSort.coe W)
-- groupCohomology.Hilbert90.aux_ne_zero
theorem aux_ne_zero (f : (L ≃ₐ[K] L) → Lˣ) : aux f ≠ 0 
Arguments: {K : Type u_1} {L : Type u_2} [Field K] [Field L] [Algebra K L] [FiniteDimensional K L] (f : (L ≃ₐ[K] L) → Lˣ)
Goal: groupCohomology.Hilbert90.aux f ≠ 0
-- groupCohomology.isMulOneCoboundary_of_isMulOneCocycle_of_aut_to_units
theorem isMulOneCoboundary_of_isMulOneCocycle_of_aut_to_units
    (f : (L ≃ₐ[K] L) → Lˣ) (hf : IsMulOneCocycle f) :
    IsMulOneCoboundary f 
Arguments: {K : Type u_1} {L : Type u_2} [Field K] [Field L] [Algebra K L] [FiniteDimensional K L] (f : (L ≃ₐ[K] L) → Lˣ) (hf : groupCohomology.IsMulOneCocycle f)
Goal: groupCohomology.IsMulOneCoboundary f
-- FDRep.char_mul_comm
theorem char_mul_comm (V : FDRep k G) (g : G) (h : G) :
    V.character (h * g) = V.character (g * h) 
Arguments: {k : Type u} [Field k] {G : Type u} [Monoid G] (V : FDRep k G) (g h : G)
Goal: V.character (h * g) = V.character (g * h)
-- FDRep.char_one
@[simp]
theorem char_one (V : FDRep k G) : V.character 1 = FiniteDimensional.finrank k V 
Arguments: {k : Type u} [Field k] {G : Type u} [Monoid G] (V : FDRep k G)
Goal: V.character 1 = ↑(FiniteDimensional.finrank k (CoeSort.coe V))
-- FDRep.char_tensor
theorem char_tensor (V W : FDRep k G) : (V ⊗ W).character = V.character * W.character 
Arguments: {k : Type u} [Field k] {G : Type u} [Monoid G] (V W : FDRep k G)
Goal: (V ⊗ W).character = V.character * W.character
-- FDRep.char_tensor'
@[simp]
theorem char_tensor' (V W : FDRep k G) :
    character (Action.FunctorCategoryEquivalence.inverse.obj
    (Action.FunctorCategoryEquivalence.functor.obj V ⊗
     Action.FunctorCategoryEquivalence.functor.obj W)) = V.character * W.character 
Arguments: {k : Type u} [Field k] {G : Type u} [Monoid G] (V W : FDRep k G)
Goal: FDRep.character
    (Action.FunctorCategoryEquivalence.inverse.obj
      (Action.FunctorCategoryEquivalence.functor.obj V ⊗ Action.FunctorCategoryEquivalence.functor.obj W)) =
  V.character * W.character
-- FDRep.char_iso
theorem char_iso {V W : FDRep k G} (i : V ≅ W) : V.character = W.character 
Arguments: {k : Type u} [Field k] {G : Type u} [Monoid G] {V W : FDRep k G} (i : V ≅ W)
Goal: V.character = W.character
-- FDRep.char_conj
@[simp]
theorem char_conj (V : FDRep k G) (g : G) (h : G) : V.character (h * g * h⁻¹) = V.character g 
Arguments: {k : Type u} [Field k] {G : Type u} [Group G] (V : FDRep k G) (g h : G)
Goal: V.character (h * g * h⁻¹) = V.character g
-- FDRep.char_dual
@[simp]
theorem char_dual (V : FDRep k G) (g : G) : (of (dual V.ρ)).character g = V.character g⁻¹ 
Arguments: {k : Type u} [Field k] {G : Type u} [Group G] (V : FDRep k G) (g : G)
Goal: (FDRep.of (Representation.dual V.ρ)).character g = V.character g⁻¹
-- FDRep.char_linHom
@[simp]
theorem char_linHom (V W : FDRep k G) (g : G) :
    (of (linHom V.ρ W.ρ)).character g = V.character g⁻¹ * W.character g 
Arguments: {k : Type u} [Field k] {G : Type u} [Group G] (V W : FDRep k G) (g : G)
Goal: (FDRep.of (Representation.linHom V.ρ W.ρ)).character g = V.character g⁻¹ * W.character g
-- FDRep.average_char_eq_finrank_invariants
theorem average_char_eq_finrank_invariants (V : FDRep k G) :
    ⅟ (Fintype.card G : k) • ∑ g : G, V.character g = finrank k (invariants V.ρ) 
Arguments: {k : Type u} [Field k] {G : Type u} [Group G] [Fintype G] [Invertible ↑(Fintype.card G)] (V : FDRep k G)
Goal: ⅟↑(Fintype.card G) • ∑ g : G, V.character g = ↑(FiniteDimensional.finrank k ↥(Representation.invariants V.ρ))
-- FDRep.char_orthonormal
theorem char_orthonormal (V W : FDRep k G) [Simple V] [Simple W] :
    ⅟ (Fintype.card G : k) • ∑ g : G, V.character g * W.character g⁻¹ =
      if Nonempty (V ≅ W) then ↑1 else ↑0 
Arguments: {k : Type u} [Field k] {G : Grp} [IsAlgClosed k] [Fintype ↑G] [Invertible ↑(Fintype.card ↑G)] (V W : FDRep k ↑G) [CategoryTheory.Simple V] [CategoryTheory.Simple W]
Goal: ⅟↑(Fintype.card ↑G) • ∑ g : ↑G, V.character g * W.character g⁻¹ = if Nonempty (V ≅ W) then 1 else 0
-- Zsqrtd.ofInt_re
theorem ofInt_re (n : ℤ) : (ofInt n : ℤ√d).re = n 
Arguments: {d : ℤ} (n : ℤ)
Goal: (Zsqrtd.ofInt n).re = n
-- Zsqrtd.ofInt_im
theorem ofInt_im (n : ℤ) : (ofInt n : ℤ√d).im = 0 
Arguments: {d : ℤ} (n : ℤ)
Goal: (Zsqrtd.ofInt n).im = 0
-- Zsqrtd.zero_re
@[simp]
theorem zero_re : (0 : ℤ√d).re = 0 
Arguments: {d : ℤ}
Goal: Zsqrtd.re 0 = 0
-- Zsqrtd.zero_im
@[simp]
theorem zero_im : (0 : ℤ√d).im = 0 
Arguments: {d : ℤ}
Goal: Zsqrtd.im 0 = 0
-- Zsqrtd.one_re
@[simp]
theorem one_re : (1 : ℤ√d).re = 1 
Arguments: {d : ℤ}
Goal: Zsqrtd.re 1 = 1
-- Zsqrtd.one_im
@[simp]
theorem one_im : (1 : ℤ√d).im = 0 
Arguments: {d : ℤ}
Goal: Zsqrtd.im 1 = 0
-- Zsqrtd.sqrtd_re
@[simp]
theorem sqrtd_re : (sqrtd : ℤ√d).re = 0 
Arguments: {d : ℤ}
Goal: Zsqrtd.sqrtd.re = 0
-- Zsqrtd.sqrtd_im
@[simp]
theorem sqrtd_im : (sqrtd : ℤ√d).im = 1 
Arguments: {d : ℤ}
Goal: Zsqrtd.sqrtd.im = 1
-- Zsqrtd.add_def
@[simp]
theorem add_def (x y x' y' : ℤ) : (⟨x, y⟩ + ⟨x', y'⟩ : ℤ√d) = ⟨x + x', y + y'⟩ 
Arguments: {d : ℤ} (x y x' y' : ℤ)
Goal: { re := x, im := y } + { re := x', im := y' } = { re := x + x', im := y + y' }
-- Zsqrtd.add_re
@[simp]
theorem add_re (z w : ℤ√d) : (z + w).re = z.re + w.re 
Arguments: {d : ℤ} (z w : ℤ√d)
Goal: (z + w).re = z.re + w.re
-- Zsqrtd.add_im
@[simp]
theorem add_im (z w : ℤ√d) : (z + w).im = z.im + w.im 
Arguments: {d : ℤ} (z w : ℤ√d)
Goal: (z + w).im = z.im + w.im
-- Zsqrtd.neg_re
@[simp]
theorem neg_re (z : ℤ√d) : (-z).re = -z.re 
Arguments: {d : ℤ} (z : ℤ√d)
Goal: (-z).re = -z.re
-- Zsqrtd.neg_im
@[simp]
theorem neg_im (z : ℤ√d) : (-z).im = -z.im 
Arguments: {d : ℤ} (z : ℤ√d)
Goal: (-z).im = -z.im
-- Zsqrtd.mul_re
@[simp]
theorem mul_re (z w : ℤ√d) : (z * w).re = z.re * w.re + d * z.im * w.im 
Arguments: {d : ℤ} (z w : ℤ√d)
Goal: (z * w).re = z.re * w.re + d * z.im * w.im
-- Zsqrtd.mul_im
@[simp]
theorem mul_im (z w : ℤ√d) : (z * w).im = z.re * w.im + z.im * w.re 
Arguments: {d : ℤ} (z w : ℤ√d)
Goal: (z * w).im = z.re * w.im + z.im * w.re
-- Zsqrtd.sub_re
@[simp]
theorem sub_re (z w : ℤ√d) : (z - w).re = z.re - w.re 
Arguments: {d : ℤ} (z w : ℤ√d)
Goal: (z - w).re = z.re - w.re
-- Zsqrtd.sub_im
@[simp]
theorem sub_im (z w : ℤ√d) : (z - w).im = z.im - w.im 
Arguments: {d : ℤ} (z w : ℤ√d)
Goal: (z - w).im = z.im - w.im
-- Zsqrtd.star_mk
@[simp]
theorem star_mk (x y : ℤ) : star (⟨x, y⟩ : ℤ√d) = ⟨x, -y⟩ 
Arguments: {d : ℤ} (x y : ℤ)
Goal: star { re := x, im := y } = { re := x, im := -y }
-- Zsqrtd.star_re
@[simp]
theorem star_re (z : ℤ√d) : (star z).re = z.re 
Arguments: {d : ℤ} (z : ℤ√d)
Goal: (star z).re = z.re
-- Zsqrtd.star_im
@[simp]
theorem star_im (z : ℤ√d) : (star z).im = -z.im 
Arguments: {d : ℤ} (z : ℤ√d)
Goal: (star z).im = -z.im
-- Zsqrtd.natCast_re
@[simp]
theorem natCast_re (n : ℕ) : (n : ℤ√d).re = n 
Arguments: {d : ℤ} (n : ℕ)
Goal: (↑n).re = ↑n
-- Zsqrtd.ofNat_re
@[simp]
theorem ofNat_re (n : ℕ) [n.AtLeastTwo] : (no_index (OfNat.ofNat n) : ℤ√d).re = n 
Arguments: {d : ℤ} (n : ℕ) [n.AtLeastTwo]
Goal: (OfNat.ofNat n).re = ↑n
-- Zsqrtd.natCast_im
@[simp]
theorem natCast_im (n : ℕ) : (n : ℤ√d).im = 0 
Arguments: {d : ℤ} (n : ℕ)
Goal: (↑n).im = 0
-- Zsqrtd.ofNat_im
@[simp]
theorem ofNat_im (n : ℕ) [n.AtLeastTwo] : (no_index (OfNat.ofNat n) : ℤ√d).im = 0 
Arguments: {d : ℤ} (n : ℕ) [n.AtLeastTwo]
Goal: (OfNat.ofNat n).im = 0
-- Zsqrtd.natCast_val
theorem natCast_val (n : ℕ) : (n : ℤ√d) = ⟨n, 0⟩ 
Arguments: {d : ℤ} (n : ℕ)
Goal: ↑n = { re := ↑n, im := 0 }
-- Zsqrtd.intCast_re
@[simp]
theorem intCast_re (n : ℤ) : (n : ℤ√d).re = n 
Arguments: {d : ℤ} (n : ℤ)
Goal: (↑n).re = n
-- Zsqrtd.intCast_im
@[simp]
theorem intCast_im (n : ℤ) : (n : ℤ√d).im = 0 
Arguments: {d : ℤ} (n : ℤ)
Goal: (↑n).im = 0
-- Zsqrtd.intCast_val
theorem intCast_val (n : ℤ) : (n : ℤ√d) = ⟨n, 0⟩ 
Arguments: {d : ℤ} (n : ℤ)
Goal: ↑n = { re := n, im := 0 }
-- Zsqrtd.ofInt_eq_intCast
@[simp]
theorem ofInt_eq_intCast (n : ℤ) : (ofInt n : ℤ√d) = n 
Arguments: {d : ℤ} (n : ℤ)
Goal: Zsqrtd.ofInt n = ↑n
-- Zsqrtd.smul_val
@[simp]
theorem smul_val (n x y : ℤ) : (n : ℤ√d) * ⟨x, y⟩ = ⟨n * x, n * y⟩ 
Arguments: {d : ℤ} (n x y : ℤ)
Goal: ↑n * { re := x, im := y } = { re := n * x, im := n * y }
-- Zsqrtd.smul_re
theorem smul_re (a : ℤ) (b : ℤ√d) : (↑a * b).re = a * b.re 
Arguments: {d : ℤ} (a : ℤ) (b : ℤ√d)
Goal: (↑a * b).re = a * b.re
-- Zsqrtd.smul_im
theorem smul_im (a : ℤ) (b : ℤ√d) : (↑a * b).im = a * b.im 
Arguments: {d : ℤ} (a : ℤ) (b : ℤ√d)
Goal: (↑a * b).im = a * b.im
-- Zsqrtd.muld_val
@[simp]
theorem muld_val (x y : ℤ) : sqrtd (d := d) * ⟨x, y⟩ = ⟨d * y, x⟩ 
Arguments: {d : ℤ} (x y : ℤ)
Goal: Zsqrtd.sqrtd * { re := x, im := y } = { re := d * y, im := x }
-- Zsqrtd.dmuld
@[simp]
theorem dmuld : sqrtd (d := d) * sqrtd (d := d) = d 
Arguments: {d : ℤ}
Goal: Zsqrtd.sqrtd * Zsqrtd.sqrtd = ↑d
-- Zsqrtd.smuld_val
@[simp]
theorem smuld_val (n x y : ℤ) : sqrtd * (n : ℤ√d) * ⟨x, y⟩ = ⟨d * n * y, n * x⟩ 
Arguments: {d : ℤ} (n x y : ℤ)
Goal: Zsqrtd.sqrtd * ↑n * { re := x, im := y } = { re := d * n * y, im := n * x }
-- Zsqrtd.decompose
theorem decompose {x y : ℤ} : (⟨x, y⟩ : ℤ√d) = x + sqrtd (d := d) * y 
Arguments: {d x y : ℤ}
Goal: { re := x, im := y } = ↑x + Zsqrtd.sqrtd * ↑y
-- Zsqrtd.mul_star
theorem mul_star {x y : ℤ} : (⟨x, y⟩ * star ⟨x, y⟩ : ℤ√d) = x * x - d * y * y 
Arguments: {d x y : ℤ}
Goal: { re := x, im := y } * star { re := x, im := y } = ↑x * ↑x - ↑d * ↑y * ↑y
-- Zsqrtd.intCast_dvd
theorem intCast_dvd (z : ℤ) (a : ℤ√d) : ↑z ∣ a ↔ z ∣ a.re ∧ z ∣ a.im 
Arguments: {d : ℤ} (z : ℤ) (a : ℤ√d)
Goal: ↑z ∣ a ↔ z ∣ a.re ∧ z ∣ a.im
-- Zsqrtd.intCast_dvd_intCast
@[simp, norm_cast]
theorem intCast_dvd_intCast (a b : ℤ) : (a : ℤ√d) ∣ b ↔ a ∣ b 
Arguments: {d : ℤ} (a b : ℤ)
Goal: ↑a ∣ ↑b ↔ a ∣ b
-- Zsqrtd.eq_of_smul_eq_smul_left
protected theorem eq_of_smul_eq_smul_left {a : ℤ} {b c : ℤ√d} (ha : a ≠ 0) (h : ↑a * b = a * c) :
    b = c 
Arguments: {d a : ℤ} {b c : ℤ√d} (ha : a ≠ 0) (h : ↑a * b = ↑a * c)
Goal: b = c
-- Zsqrtd.gcd_eq_zero_iff
theorem gcd_eq_zero_iff (a : ℤ√d) : Int.gcd a.re a.im = 0 ↔ a = 0 
Arguments: {d : ℤ} (a : ℤ√d)
Goal: a.re.gcd a.im = 0 ↔ a = 0
-- Zsqrtd.gcd_pos_iff
theorem gcd_pos_iff (a : ℤ√d) : 0 < Int.gcd a.re a.im ↔ a ≠ 0 
Arguments: {d : ℤ} (a : ℤ√d)
Goal: 0 < a.re.gcd a.im ↔ a ≠ 0
-- Zsqrtd.coprime_of_dvd_coprime
theorem coprime_of_dvd_coprime {a b : ℤ√d} (hcoprime : IsCoprime a.re a.im) (hdvd : b ∣ a) :
    IsCoprime b.re b.im 
Arguments: {d : ℤ} {a b : ℤ√d} (hcoprime : IsCoprime a.re a.im) (hdvd : b ∣ a)
Goal: IsCoprime b.re b.im
-- Zsqrtd.exists_coprime_of_gcd_pos
theorem exists_coprime_of_gcd_pos {a : ℤ√d} (hgcd : 0 < Int.gcd a.re a.im) :
    ∃ b : ℤ√d, a = ((Int.gcd a.re a.im : ℤ) : ℤ√d) * b ∧ IsCoprime b.re b.im 
Arguments: {d : ℤ} {a : ℤ√d} (hgcd : 0 < a.re.gcd a.im)
Goal: ∃ b, a = ↑↑(a.re.gcd a.im) * b ∧ IsCoprime b.re b.im
-- Zsqrtd.sqLe_of_le
theorem sqLe_of_le {c d x y z w : ℕ} (xz : z ≤ x) (yw : y ≤ w) (xy : SqLe x c y d) : SqLe z c w d 
Arguments: {c d x y z w : ℕ} (xz : z ≤ x) (yw : y ≤ w) (xy : Zsqrtd.SqLe x c y d)
Goal: Zsqrtd.SqLe z c w d
-- Zsqrtd.sqLe_add_mixed
theorem sqLe_add_mixed {c d x y z w : ℕ} (xy : SqLe x c y d) (zw : SqLe z c w d) :
    c * (x * z) ≤ d * (y * w) 
Arguments: {c d x y z w : ℕ} (xy : Zsqrtd.SqLe x c y d) (zw : Zsqrtd.SqLe z c w d)
Goal: c * (x * z) ≤ d * (y * w)
-- Zsqrtd.sqLe_add
theorem sqLe_add {c d x y z w : ℕ} (xy : SqLe x c y d) (zw : SqLe z c w d) :
    SqLe (x + z) c (y + w) d 
Arguments: {c d x y z w : ℕ} (xy : Zsqrtd.SqLe x c y d) (zw : Zsqrtd.SqLe z c w d)
Goal: Zsqrtd.SqLe (x + z) c (y + w) d
-- Zsqrtd.sqLe_cancel
theorem sqLe_cancel {c d x y z w : ℕ} (zw : SqLe y d x c) (h : SqLe (x + z) c (y + w) d) :
    SqLe z c w d 
Arguments: {c d x y z w : ℕ} (zw : Zsqrtd.SqLe y d x c) (h : Zsqrtd.SqLe (x + z) c (y + w) d)
Goal: Zsqrtd.SqLe z c w d
-- Zsqrtd.sqLe_smul
theorem sqLe_smul {c d x y : ℕ} (n : ℕ) (xy : SqLe x c y d) : SqLe (n * x) c (n * y) d 
Arguments: {c d x y : ℕ} (n : ℕ) (xy : Zsqrtd.SqLe x c y d)
Goal: Zsqrtd.SqLe (n * x) c (n * y) d
-- Zsqrtd.sqLe_mul
theorem sqLe_mul {d x y z w : ℕ} :
    (SqLe x 1 y d → SqLe z 1 w d → SqLe (x * w + y * z) d (x * z + d * y * w) 1) ∧
      (SqLe x 1 y d → SqLe w d z 1 → SqLe (x * z + d * y * w) 1 (x * w + y * z) d) ∧
        (SqLe y d x 1 → SqLe z 1 w d → SqLe (x * z + d * y * w) 1 (x * w + y * z) d) ∧
          (SqLe y d x 1 → SqLe w d z 1 → SqLe (x * w + y * z) d (x * z + d * y * w) 1) 
Arguments: {d x y z w : ℕ}
Goal: (Zsqrtd.SqLe x 1 y d → Zsqrtd.SqLe z 1 w d → Zsqrtd.SqLe (x * w + y * z) d (x * z + d * y * w) 1) ∧
  (Zsqrtd.SqLe x 1 y d → Zsqrtd.SqLe w d z 1 → Zsqrtd.SqLe (x * z + d * y * w) 1 (x * w + y * z) d) ∧
    (Zsqrtd.SqLe y d x 1 → Zsqrtd.SqLe z 1 w d → Zsqrtd.SqLe (x * z + d * y * w) 1 (x * w + y * z) d) ∧
      (Zsqrtd.SqLe y d x 1 → Zsqrtd.SqLe w d z 1 → Zsqrtd.SqLe (x * w + y * z) d (x * z + d * y * w) 1)
-- Zsqrtd.nonnegg_comm
theorem nonnegg_comm {c d : ℕ} {x y : ℤ} : Nonnegg c d x y = Nonnegg d c y x 
Arguments: {c d : ℕ} {x y : ℤ}
Goal: Zsqrtd.Nonnegg c d x y = Zsqrtd.Nonnegg d c y x
-- Zsqrtd.nonnegg_neg_pos
theorem nonnegg_neg_pos {c d} : ∀ {a b : ℕ}, Nonnegg c d (-a) b ↔ SqLe a d b c
  
Arguments: {c d a b : ℕ}
Goal: Zsqrtd.Nonnegg c d (-↑a) ↑b ↔ Zsqrtd.SqLe a d b c
-- Zsqrtd.nonnegg_pos_neg
theorem nonnegg_pos_neg {c d} {a b : ℕ} : Nonnegg c d a (-b) ↔ SqLe b c a d 
Arguments: {c d a b : ℕ}
Goal: Zsqrtd.Nonnegg c d (↑a) (-↑b) ↔ Zsqrtd.SqLe b c a d
-- Zsqrtd.nonnegg_cases_right
theorem nonnegg_cases_right {c d} {a : ℕ} :
    ∀ {b : ℤ}, (∀ x : ℕ, b = -x → SqLe x c a d) → Nonnegg c d a b
  
Arguments: {c d a : ℕ} {b : ℤ}
Goal: (∀ (x : ℕ), b = -↑x → Zsqrtd.SqLe x c a d) → Zsqrtd.Nonnegg c d (↑a) b
-- Zsqrtd.nonnegg_cases_left
theorem nonnegg_cases_left {c d} {b : ℕ} {a : ℤ} (h : ∀ x : ℕ, a = -x → SqLe x d b c) :
    Nonnegg c d a b 
Arguments: {c d b : ℕ} {a : ℤ} (h : ∀ (x : ℕ), a = -↑x → Zsqrtd.SqLe x d b c)
Goal: Zsqrtd.Nonnegg c d a ↑b
-- Zsqrtd.norm_def
theorem norm_def (n : ℤ√d) : n.norm = n.re * n.re - d * n.im * n.im 
Arguments: {d : ℤ} (n : ℤ√d)
Goal: n.norm = n.re * n.re - d * n.im * n.im
-- Zsqrtd.norm_zero
@[simp]
theorem norm_zero : norm (0 : ℤ√d) = 0 
Arguments: {d : ℤ}
Goal: Zsqrtd.norm 0 = 0