Theorem: NumberField.mixedEmbedding.convexBodyLT_volume
File: Mathlib/NumberTheory/NumberField/CanonicalEmbedding/ConvexBody.lean

tactic: simp_rw [volume_eq_prod, prod_prod, volume_pi, pi_pi, Real.volume_ball, Complex.volume_ball]
state_before: K : Type u_1
inst✝¹ : Field K
f : InfinitePlace K → ℝ≥0
inst✝ : NumberField K
⊢ volume (convexBodyLT K f) =
    (∏ x : { w // w.IsReal }, ENNReal.ofReal (2 * ↑(f ↑x))) *
      ∏ x : { w // w.IsComplex }, ENNReal.ofReal ↑(f ↑x) ^ 2 * ↑pi
state_after: no goals

tactic: simp_rw [ofReal_mul (by norm_num : 0 ≤ (2 : ℝ)), Finset.prod_mul_distrib, Finset.prod_const,
  Finset.card_univ, ofReal_ofNat, ofReal_coe_nnreal, coe_ofNat]
state_before: K : Type u_1
inst✝¹ : Field K
f : InfinitePlace K → ℝ≥0
inst✝ : NumberField K
⊢ (∏ x : { w // w.IsReal }, ENNReal.ofReal (2 * ↑(f ↑x))) *
      ∏ x : { w // w.IsComplex }, ENNReal.ofReal ↑(f ↑x) ^ 2 * ↑pi =
    (↑2 ^ NrRealPlaces K * ∏ x : { w // w.IsReal }, ENNReal.ofReal ↑(f ↑x)) *
      ((∏ x : { w // w.IsComplex }, ENNReal.ofReal ↑(f ↑x) ^ 2) * ↑pi ^ NrComplexPlaces K)
state_after: no goals

tactic: norm_num
state_before: K : Type u_1
inst✝¹ : Field K
f : InfinitePlace K → ℝ≥0
inst✝ : NumberField K
⊢ 0 ≤ 2
state_after: no goals

tactic: simp_rw [convexBodyLTFactor, coe_mul, ENNReal.coe_pow]
state_before: K : Type u_1
inst✝¹ : Field K
f : InfinitePlace K → ℝ≥0
inst✝ : NumberField K
⊢ (↑2 ^ NrRealPlaces K * ∏ x : { w // w.IsReal }, ENNReal.ofReal ↑(f ↑x)) *
      ((∏ x : { w // w.IsComplex }, ENNReal.ofReal ↑(f ↑x) ^ 2) * ↑pi ^ NrComplexPlaces K) =
    ↑(convexBodyLTFactor K) *
      ((∏ x : { w // w.IsReal }, ENNReal.ofReal ↑(f ↑x)) * ∏ x : { w // w.IsComplex }, ENNReal.ofReal ↑(f ↑x) ^ 2)
state_after: K : Type u_1
inst✝¹ : Field K
f : InfinitePlace K → ℝ≥0
inst✝ : NumberField K
⊢ (↑2 ^ NrRealPlaces K * ∏ x : { w // w.IsReal }, ENNReal.ofReal ↑(f ↑x)) *
      ((∏ x : { w // w.IsComplex }, ENNReal.ofReal ↑(f ↑x) ^ 2) * ↑pi ^ NrComplexPlaces K) =
    ↑2 ^ NrRealPlaces K * ↑pi ^ NrComplexPlaces K *
      ((∏ x : { w // w.IsReal }, ENNReal.ofReal ↑(f ↑x)) * ∏ x : { w // w.IsComplex }, ENNReal.ofReal ↑(f ↑x) ^ 2)

tactic: ring
state_before: K : Type u_1
inst✝¹ : Field K
f : InfinitePlace K → ℝ≥0
inst✝ : NumberField K
⊢ (↑2 ^ NrRealPlaces K * ∏ x : { w // w.IsReal }, ENNReal.ofReal ↑(f ↑x)) *
      ((∏ x : { w // w.IsComplex }, ENNReal.ofReal ↑(f ↑x) ^ 2) * ↑pi ^ NrComplexPlaces K) =
    ↑2 ^ NrRealPlaces K * ↑pi ^ NrComplexPlaces K *
      ((∏ x : { w // w.IsReal }, ENNReal.ofReal ↑(f ↑x)) * ∏ x : { w // w.IsComplex }, ENNReal.ofReal ↑(f ↑x) ^ 2)
state_after: no goals

tactic: simp_rw [mult, pow_ite, pow_one, Finset.prod_ite, ofReal_coe_nnreal, not_isReal_iff_isComplex,
  coe_mul, coe_finset_prod, ENNReal.coe_pow]
state_before: K : Type u_1
inst✝¹ : Field K
f : InfinitePlace K → ℝ≥0
inst✝ : NumberField K
⊢ ↑(convexBodyLTFactor K) *
      ((∏ x : { w // w.IsReal }, ENNReal.ofReal ↑(f ↑x)) * ∏ x : { w // w.IsComplex }, ENNReal.ofReal ↑(f ↑x) ^ 2) =
    ↑(convexBodyLTFactor K) * ↑(∏ w : InfinitePlace K, f w ^ w.mult)
state_after: K : Type u_1
inst✝¹ : Field K
f : InfinitePlace K → ℝ≥0
inst✝ : NumberField K
⊢ ↑2 ^ NrRealPlaces K * ↑pi ^ NrComplexPlaces K *
      ((∏ x : { w // w.IsReal }, ↑(f ↑x)) * ∏ x : { w // w.IsComplex }, ↑(f ↑x) ^ 2) =
    ↑2 ^ NrRealPlaces K * ↑pi ^ NrComplexPlaces K *
      ((∏ a ∈ Finset.filter IsReal Finset.univ, ↑(f a)) *
        ∏ x ∈ Finset.filter (fun x => x.IsComplex) Finset.univ, ↑(f x) ^ 2)

tactic: congr 2
state_before: K : Type u_1
inst✝¹ : Field K
f : InfinitePlace K → ℝ≥0
inst✝ : NumberField K
⊢ ↑2 ^ NrRealPlaces K * ↑pi ^ NrComplexPlaces K *
      ((∏ x : { w // w.IsReal }, ↑(f ↑x)) * ∏ x : { w // w.IsComplex }, ↑(f ↑x) ^ 2) =
    ↑2 ^ NrRealPlaces K * ↑pi ^ NrComplexPlaces K *
      ((∏ a ∈ Finset.filter IsReal Finset.univ, ↑(f a)) *
        ∏ x ∈ Finset.filter (fun x => x.IsComplex) Finset.univ, ↑(f x) ^ 2)
state_after: case e_a.e_a
K : Type u_1
inst✝¹ : Field K
f : InfinitePlace K → ℝ≥0
inst✝ : NumberField K
⊢ ∏ x : { w // w.IsReal }, ↑(f ↑x) = ∏ a ∈ Finset.filter IsReal Finset.univ, ↑(f a)

case e_a.e_a
K : Type u_1
inst✝¹ : Field K
f : InfinitePlace K → ℝ≥0
inst✝ : NumberField K
⊢ ∏ x : { w // w.IsComplex }, ↑(f ↑x) ^ 2 = ∏ x ∈ Finset.filter (fun x => x.IsComplex) Finset.univ, ↑(f x) ^ 2

tactic: refine (Finset.prod_subtype (Finset.univ.filter _) ?_ (fun w => (f w : ℝ≥0∞))).symm
state_before: case e_a.e_a
K : Type u_1
inst✝¹ : Field K
f : InfinitePlace K → ℝ≥0
inst✝ : NumberField K
⊢ ∏ x : { w // w.IsReal }, ↑(f ↑x) = ∏ a ∈ Finset.filter IsReal Finset.univ, ↑(f a)
state_after: case e_a.e_a
K : Type u_1
inst✝¹ : Field K
f : InfinitePlace K → ℝ≥0
inst✝ : NumberField K
⊢ ∀ (x : InfinitePlace K), x ∈ Finset.filter IsReal Finset.univ ↔ x.IsReal

tactic: exact fun _ => by simp only [Finset.mem_univ, forall_true_left, Finset.mem_filter, true_and]
state_before: case e_a.e_a
K : Type u_1
inst✝¹ : Field K
f : InfinitePlace K → ℝ≥0
inst✝ : NumberField K
⊢ ∀ (x : InfinitePlace K), x ∈ Finset.filter IsReal Finset.univ ↔ x.IsReal
state_after: no goals

tactic: simp only [Finset.mem_univ, forall_true_left, Finset.mem_filter, true_and]
state_before: K : Type u_1
inst✝¹ : Field K
f : InfinitePlace K → ℝ≥0
inst✝ : NumberField K
x✝ : InfinitePlace K
⊢ x✝ ∈ Finset.filter IsReal Finset.univ ↔ x✝.IsReal
state_after: no goals

tactic: refine (Finset.prod_subtype (Finset.univ.filter _) ?_ (fun w => (f w : ℝ≥0∞) ^ 2)).symm
state_before: case e_a.e_a
K : Type u_1
inst✝¹ : Field K
f : InfinitePlace K → ℝ≥0
inst✝ : NumberField K
⊢ ∏ x : { w // w.IsComplex }, ↑(f ↑x) ^ 2 = ∏ x ∈ Finset.filter (fun x => x.IsComplex) Finset.univ, ↑(f x) ^ 2
state_after: case e_a.e_a
K : Type u_1
inst✝¹ : Field K
f : InfinitePlace K → ℝ≥0
inst✝ : NumberField K
⊢ ∀ (x : InfinitePlace K), x ∈ Finset.filter (fun x => x.IsComplex) Finset.univ ↔ x.IsComplex

tactic: exact fun _ => by simp only [Finset.mem_univ, forall_true_left, Finset.mem_filter, true_and]
state_before: case e_a.e_a
K : Type u_1
inst✝¹ : Field K
f : InfinitePlace K → ℝ≥0
inst✝ : NumberField K
⊢ ∀ (x : InfinitePlace K), x ∈ Finset.filter (fun x => x.IsComplex) Finset.univ ↔ x.IsComplex
state_after: no goals

tactic: simp only [Finset.mem_univ, forall_true_left, Finset.mem_filter, true_and]
state_before: K : Type u_1
inst✝¹ : Field K
f : InfinitePlace K → ℝ≥0
inst✝ : NumberField K
x✝ : InfinitePlace K
⊢ x✝ ∈ Finset.filter (fun x => x.IsComplex) Finset.univ ↔ x✝.IsComplex
state_after: no goals