ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- MeasureTheory.martingale_nat
theorem martingale_nat [IsFiniteMeasure μ] {f : ℕ → Ω → ℝ} (hadp : Adapted 𝒢 f)
    (hint : ∀ i, Integrable (f i) μ) (hf : ∀ i, f i =ᵐ[μ] μ[f (i + 1)|𝒢 i]) : Martingale f 𝒢 μ 
Arguments: {Ω : Type u_1} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {𝒢 : MeasureTheory.Filtration ℕ m0} [MeasureTheory.IsFiniteMeasure μ] {f : ℕ → Ω → ℝ} (hadp : MeasureTheory.Adapted 𝒢 f) (hint : ∀ (i : ℕ), MeasureTheory.Integrable (f i) μ) (hf : ∀ (i : ℕ), f i =ᵐ[μ] μ[f (i + 1)|↑𝒢 i])
Goal: MeasureTheory.Martingale f 𝒢 μ
-- MeasureTheory.submartingale_of_condexp_sub_nonneg_nat
theorem submartingale_of_condexp_sub_nonneg_nat [IsFiniteMeasure μ] {f : ℕ → Ω → ℝ}
    (hadp : Adapted 𝒢 f) (hint : ∀ i, Integrable (f i) μ)
    (hf : ∀ i, 0 ≤ᵐ[μ] μ[f (i + 1) - f i|𝒢 i]) : Submartingale f 𝒢 μ 
Arguments: {Ω : Type u_1} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {𝒢 : MeasureTheory.Filtration ℕ m0} [MeasureTheory.IsFiniteMeasure μ] {f : ℕ → Ω → ℝ} (hadp : MeasureTheory.Adapted 𝒢 f) (hint : ∀ (i : ℕ), MeasureTheory.Integrable (f i) μ) (hf : ∀ (i : ℕ), 0 ≤ᵐ[μ] μ[f (i + 1) - f i|↑𝒢 i])
Goal: MeasureTheory.Submartingale f 𝒢 μ
-- MeasureTheory.supermartingale_of_condexp_sub_nonneg_nat
theorem supermartingale_of_condexp_sub_nonneg_nat [IsFiniteMeasure μ] {f : ℕ → Ω → ℝ}
    (hadp : Adapted 𝒢 f) (hint : ∀ i, Integrable (f i) μ)
    (hf : ∀ i, 0 ≤ᵐ[μ] μ[f i - f (i + 1)|𝒢 i]) : Supermartingale f 𝒢 μ 
Arguments: {Ω : Type u_1} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {𝒢 : MeasureTheory.Filtration ℕ m0} [MeasureTheory.IsFiniteMeasure μ] {f : ℕ → Ω → ℝ} (hadp : MeasureTheory.Adapted 𝒢 f) (hint : ∀ (i : ℕ), MeasureTheory.Integrable (f i) μ) (hf : ∀ (i : ℕ), 0 ≤ᵐ[μ] μ[f i - f (i + 1)|↑𝒢 i])
Goal: MeasureTheory.Supermartingale f 𝒢 μ
-- MeasureTheory.martingale_of_condexp_sub_eq_zero_nat
theorem martingale_of_condexp_sub_eq_zero_nat [IsFiniteMeasure μ] {f : ℕ → Ω → ℝ}
    (hadp : Adapted 𝒢 f) (hint : ∀ i, Integrable (f i) μ)
    (hf : ∀ i, μ[f (i + 1) - f i|𝒢 i] =ᵐ[μ] 0) : Martingale f 𝒢 μ 
Arguments: {Ω : Type u_1} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {𝒢 : MeasureTheory.Filtration ℕ m0} [MeasureTheory.IsFiniteMeasure μ] {f : ℕ → Ω → ℝ} (hadp : MeasureTheory.Adapted 𝒢 f) (hint : ∀ (i : ℕ), MeasureTheory.Integrable (f i) μ) (hf : ∀ (i : ℕ), μ[f (i + 1) - f i|↑𝒢 i] =ᵐ[μ] 0)
Goal: MeasureTheory.Martingale f 𝒢 μ
-- MeasureTheory.Submartingale.zero_le_of_predictable
theorem Submartingale.zero_le_of_predictable [Preorder E] [SigmaFiniteFiltration μ 𝒢]
    {f : ℕ → Ω → E} (hfmgle : Submartingale f 𝒢 μ) (hfadp : Adapted 𝒢 fun n => f (n + 1)) (n : ℕ) :
    f 0 ≤ᵐ[μ] f n 
Arguments: {Ω : Type u_1} {E : Type u_2} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E] {𝒢 : MeasureTheory.Filtration ℕ m0} [Preorder E] [MeasureTheory.SigmaFiniteFiltration μ 𝒢] {f : ℕ → Ω → E} (hfmgle : MeasureTheory.Submartingale f 𝒢 μ) (hfadp : MeasureTheory.Adapted 𝒢 fun n => f (n + 1)) (n : ℕ)
Goal: f 0 ≤ᵐ[μ] f n
-- MeasureTheory.Supermartingale.le_zero_of_predictable
theorem Supermartingale.le_zero_of_predictable [Preorder E] [SigmaFiniteFiltration μ 𝒢]
    {f : ℕ → Ω → E} (hfmgle : Supermartingale f 𝒢 μ) (hfadp : Adapted 𝒢 fun n => f (n + 1))
    (n : ℕ) : f n ≤ᵐ[μ] f 0 
Arguments: {Ω : Type u_1} {E : Type u_2} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E] {𝒢 : MeasureTheory.Filtration ℕ m0} [Preorder E] [MeasureTheory.SigmaFiniteFiltration μ 𝒢] {f : ℕ → Ω → E} (hfmgle : MeasureTheory.Supermartingale f 𝒢 μ) (hfadp : MeasureTheory.Adapted 𝒢 fun n => f (n + 1)) (n : ℕ)
Goal: f n ≤ᵐ[μ] f 0
-- MeasureTheory.Martingale.eq_zero_of_predictable
theorem Martingale.eq_zero_of_predictable [SigmaFiniteFiltration μ 𝒢] {f : ℕ → Ω → E}
    (hfmgle : Martingale f 𝒢 μ) (hfadp : Adapted 𝒢 fun n => f (n + 1)) (n : ℕ) : f n =ᵐ[μ] f 0 
Arguments: {Ω : Type u_1} {E : Type u_2} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E] {𝒢 : MeasureTheory.Filtration ℕ m0} [MeasureTheory.SigmaFiniteFiltration μ 𝒢] {f : ℕ → Ω → E} (hfmgle : MeasureTheory.Martingale f 𝒢 μ) (hfadp : MeasureTheory.Adapted 𝒢 fun n => f (n + 1)) (n : ℕ)
Goal: f n =ᵐ[μ] f 0
-- MeasureTheory.Submartingale.integrable_stoppedValue
protected theorem integrable_stoppedValue [LE E] {f : ℕ → Ω → E} (hf : Submartingale f 𝒢 μ)
    {τ : Ω → ℕ} (hτ : IsStoppingTime 𝒢 τ) {N : ℕ} (hbdd : ∀ ω, τ ω ≤ N) :
    Integrable (stoppedValue f τ) μ 
Arguments: {Ω : Type u_1} {E : Type u_2} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E] {𝒢 : MeasureTheory.Filtration ℕ m0} [LE E] {f : ℕ → Ω → E} (hf : MeasureTheory.Submartingale f 𝒢 μ) {τ : Ω → ℕ} (hτ : MeasureTheory.IsStoppingTime 𝒢 τ) {N : ℕ} (hbdd : ∀ (ω : Ω), τ ω ≤ N)
Goal: MeasureTheory.Integrable (MeasureTheory.stoppedValue f τ) μ
-- MeasureTheory.Submartingale.sum_mul_sub
theorem Submartingale.sum_mul_sub [IsFiniteMeasure μ] {R : ℝ} {ξ f : ℕ → Ω → ℝ}
    (hf : Submartingale f 𝒢 μ) (hξ : Adapted 𝒢 ξ) (hbdd : ∀ n ω, ξ n ω ≤ R)
    (hnonneg : ∀ n ω, 0 ≤ ξ n ω) :
    Submartingale (fun n => ∑ k ∈ Finset.range n, ξ k * (f (k + 1) - f k)) 𝒢 μ 
Arguments: {Ω : Type u_1} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {𝒢 : MeasureTheory.Filtration ℕ m0} [MeasureTheory.IsFiniteMeasure μ] {R : ℝ} {ξ f : ℕ → Ω → ℝ} (hf : MeasureTheory.Submartingale f 𝒢 μ) (hξ : MeasureTheory.Adapted 𝒢 ξ) (hbdd : ∀ (n : ℕ) (ω : Ω), ξ n ω ≤ R) (hnonneg : ∀ (n : ℕ) (ω : Ω), 0 ≤ ξ n ω)
Goal: MeasureTheory.Submartingale (fun n => ∑ k ∈ Finset.range n, ξ k * (f (k + 1) - f k)) 𝒢 μ
-- MeasureTheory.Submartingale.sum_mul_sub'
theorem Submartingale.sum_mul_sub' [IsFiniteMeasure μ] {R : ℝ} {ξ f : ℕ → Ω → ℝ}
    (hf : Submartingale f 𝒢 μ) (hξ : Adapted 𝒢 fun n => ξ (n + 1)) (hbdd : ∀ n ω, ξ n ω ≤ R)
    (hnonneg : ∀ n ω, 0 ≤ ξ n ω) :
    Submartingale (fun n => ∑ k ∈ Finset.range n, ξ (k + 1) * (f (k + 1) - f k)) 𝒢 μ 
Arguments: {Ω : Type u_1} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {𝒢 : MeasureTheory.Filtration ℕ m0} [MeasureTheory.IsFiniteMeasure μ] {R : ℝ} {ξ f : ℕ → Ω → ℝ} (hf : MeasureTheory.Submartingale f 𝒢 μ) (hξ : MeasureTheory.Adapted 𝒢 fun n => ξ (n + 1)) (hbdd : ∀ (n : ℕ) (ω : Ω), ξ n ω ≤ R) (hnonneg : ∀ (n : ℕ) (ω : Ω), 0 ≤ ξ n ω)
Goal: MeasureTheory.Submartingale (fun n => ∑ k ∈ Finset.range n, ξ (k + 1) * (f (k + 1) - f k)) 𝒢 μ
-- Polynomial.opRingEquiv_op_monomial
@[simp]
theorem opRingEquiv_op_monomial (n : ℕ) (r : R) :
    opRingEquiv R (op (monomial n r : R[X])) = monomial n (op r) 
Arguments: {R : Type u_1} [Semiring R] (n : ℕ) (r : R)
Goal: (Polynomial.opRingEquiv R) (MulOpposite.op ((Polynomial.monomial n) r)) = (Polynomial.monomial n) (MulOpposite.op r)
-- Polynomial.opRingEquiv_op_C
@[simp]
theorem opRingEquiv_op_C (a : R) : opRingEquiv R (op (C a)) = C (op a) 
Arguments: {R : Type u_1} [Semiring R] (a : R)
Goal: (Polynomial.opRingEquiv R) (MulOpposite.op (Polynomial.C a)) = Polynomial.C (MulOpposite.op a)
-- Polynomial.opRingEquiv_op_X
@[simp]
theorem opRingEquiv_op_X : opRingEquiv R (op (X : R[X])) = X 
Arguments: {R : Type u_1} [Semiring R]
Goal: (Polynomial.opRingEquiv R) (MulOpposite.op Polynomial.X) = Polynomial.X
-- Polynomial.opRingEquiv_op_C_mul_X_pow
theorem opRingEquiv_op_C_mul_X_pow (r : R) (n : ℕ) :
    opRingEquiv R (op (C r * X ^ n : R[X])) = C (op r) * X ^ n 
Arguments: {R : Type u_1} [Semiring R] (r : R) (n : ℕ)
Goal: (Polynomial.opRingEquiv R) (MulOpposite.op (Polynomial.C r * Polynomial.X ^ n)) =
  Polynomial.C (MulOpposite.op r) * Polynomial.X ^ n
-- Polynomial.opRingEquiv_symm_monomial
@[simp]
theorem opRingEquiv_symm_monomial (n : ℕ) (r : Rᵐᵒᵖ) :
    (opRingEquiv R).symm (monomial n r) = op (monomial n (unop r)) 
Arguments: {R : Type u_1} [Semiring R] (n : ℕ) (r : Rᵐᵒᵖ)
Goal: (Polynomial.opRingEquiv R).symm ((Polynomial.monomial n) r) =
  MulOpposite.op ((Polynomial.monomial n) (MulOpposite.unop r))
-- Polynomial.opRingEquiv_symm_C
@[simp]
theorem opRingEquiv_symm_C (a : Rᵐᵒᵖ) : (opRingEquiv R).symm (C a) = op (C (unop a)) 
Arguments: {R : Type u_1} [Semiring R] (a : Rᵐᵒᵖ)
Goal: (Polynomial.opRingEquiv R).symm (Polynomial.C a) = MulOpposite.op (Polynomial.C (MulOpposite.unop a))
-- Polynomial.opRingEquiv_symm_X
@[simp]
theorem opRingEquiv_symm_X : (opRingEquiv R).symm (X : Rᵐᵒᵖ[X]) = op X 
Arguments: {R : Type u_1} [Semiring R]
Goal: (Polynomial.opRingEquiv R).symm Polynomial.X = MulOpposite.op Polynomial.X
-- Polynomial.opRingEquiv_symm_C_mul_X_pow
theorem opRingEquiv_symm_C_mul_X_pow (r : Rᵐᵒᵖ) (n : ℕ) :
    (opRingEquiv R).symm (C r * X ^ n : Rᵐᵒᵖ[X]) = op (C (unop r) * X ^ n) 
Arguments: {R : Type u_1} [Semiring R] (r : Rᵐᵒᵖ) (n : ℕ)
Goal: (Polynomial.opRingEquiv R).symm (Polynomial.C r * Polynomial.X ^ n) =
  MulOpposite.op (Polynomial.C (MulOpposite.unop r) * Polynomial.X ^ n)
-- Polynomial.coeff_opRingEquiv
@[simp]
theorem coeff_opRingEquiv (p : R[X]ᵐᵒᵖ) (n : ℕ) :
    (opRingEquiv R p).coeff n = op ((unop p).coeff n) 
Arguments: {R : Type u_1} [Semiring R] (p : R[X]ᵐᵒᵖ) (n : ℕ)
Goal: ((Polynomial.opRingEquiv R) p).coeff n = MulOpposite.op ((MulOpposite.unop p).coeff n)
-- Polynomial.support_opRingEquiv
@[simp]
theorem support_opRingEquiv (p : R[X]ᵐᵒᵖ) : (opRingEquiv R p).support = (unop p).support 
Arguments: {R : Type u_1} [Semiring R] (p : R[X]ᵐᵒᵖ)
Goal: ((Polynomial.opRingEquiv R) p).support = (MulOpposite.unop p).support
-- Polynomial.natDegree_opRingEquiv
@[simp]
theorem natDegree_opRingEquiv (p : R[X]ᵐᵒᵖ) : (opRingEquiv R p).natDegree = (unop p).natDegree 
Arguments: {R : Type u_1} [Semiring R] (p : R[X]ᵐᵒᵖ)
Goal: ((Polynomial.opRingEquiv R) p).natDegree = (MulOpposite.unop p).natDegree
-- Polynomial.leadingCoeff_opRingEquiv
@[simp]
theorem leadingCoeff_opRingEquiv (p : R[X]ᵐᵒᵖ) :
    (opRingEquiv R p).leadingCoeff = op (unop p).leadingCoeff 
Arguments: {R : Type u_1} [Semiring R] (p : R[X]ᵐᵒᵖ)
Goal: ((Polynomial.opRingEquiv R) p).leadingCoeff = MulOpposite.op (MulOpposite.unop p).leadingCoeff
-- ProbabilityTheory.lintegral_mul_indicator_eq_lintegral_mul_lintegral_indicator
theorem lintegral_mul_indicator_eq_lintegral_mul_lintegral_indicator {Mf mΩ : MeasurableSpace Ω}
    {μ : Measure Ω} (hMf : Mf ≤ mΩ) (c : ℝ≥0∞) {T : Set Ω} (h_meas_T : MeasurableSet T)
    (h_ind : IndepSets {s | MeasurableSet[Mf] s} {T} μ) (h_meas_f : Measurable[Mf] f) :
    (∫⁻ ω, f ω * T.indicator (fun _ => c) ω ∂μ) =
      (∫⁻ ω, f ω ∂μ) * ∫⁻ ω, T.indicator (fun _ => c) ω ∂μ 
Arguments: {Ω : Type u_1} {f : Ω → ℝ≥0∞} {Mf mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} (hMf : Mf ≤ mΩ) (c : ℝ≥0∞) {T : Set Ω} (h_meas_T : MeasurableSet T) (h_ind : ProbabilityTheory.IndepSets {s | MeasurableSet s} {T} μ) (h_meas_f : Measurable f)
Goal: ∫⁻ (ω : Ω), f ω * T.indicator (fun x => c) ω ∂μ = (∫⁻ (ω : Ω), f ω ∂μ) * ∫⁻ (ω : Ω), T.indicator (fun x => c) ω ∂μ
-- ProbabilityTheory.lintegral_mul_eq_lintegral_mul_lintegral_of_independent_measurableSpace
theorem lintegral_mul_eq_lintegral_mul_lintegral_of_independent_measurableSpace
    {Mf Mg mΩ : MeasurableSpace Ω} {μ : Measure Ω} (hMf : Mf ≤ mΩ) (hMg : Mg ≤ mΩ)
    (h_ind : Indep Mf Mg μ) (h_meas_f : Measurable[Mf] f) (h_meas_g : Measurable[Mg] g) :
    ∫⁻ ω, f ω * g ω ∂μ = (∫⁻ ω, f ω ∂μ) * ∫⁻ ω, g ω ∂μ 
Arguments: {Ω : Type u_1} {f g : Ω → ℝ≥0∞} {Mf Mg mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} (hMf : Mf ≤ mΩ) (hMg : Mg ≤ mΩ) (h_ind : ProbabilityTheory.Indep Mf Mg μ) (h_meas_f : Measurable f) (h_meas_g : Measurable g)
Goal: ∫⁻ (ω : Ω), f ω * g ω ∂μ = (∫⁻ (ω : Ω), f ω ∂μ) * ∫⁻ (ω : Ω), g ω ∂μ
-- ProbabilityTheory.lintegral_mul_eq_lintegral_mul_lintegral_of_indepFun
theorem lintegral_mul_eq_lintegral_mul_lintegral_of_indepFun (h_meas_f : Measurable f)
    (h_meas_g : Measurable g) (h_indep_fun : IndepFun f g μ) :
    (∫⁻ ω, (f * g) ω ∂μ) = (∫⁻ ω, f ω ∂μ) * ∫⁻ ω, g ω ∂μ 
Arguments: {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {f g : Ω → ℝ≥0∞} (h_meas_f : Measurable f) (h_meas_g : Measurable g) (h_indep_fun : ProbabilityTheory.IndepFun f g μ)
Goal: ∫⁻ (ω : Ω), (f * g) ω ∂μ = (∫⁻ (ω : Ω), f ω ∂μ) * ∫⁻ (ω : Ω), g ω ∂μ
-- ProbabilityTheory.lintegral_mul_eq_lintegral_mul_lintegral_of_indepFun'
theorem lintegral_mul_eq_lintegral_mul_lintegral_of_indepFun' (h_meas_f : AEMeasurable f μ)
    (h_meas_g : AEMeasurable g μ) (h_indep_fun : IndepFun f g μ) :
    (∫⁻ ω, (f * g) ω ∂μ) = (∫⁻ ω, f ω ∂μ) * ∫⁻ ω, g ω ∂μ 
Arguments: {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {f g : Ω → ℝ≥0∞} (h_meas_f : AEMeasurable f μ) (h_meas_g : AEMeasurable g μ) (h_indep_fun : ProbabilityTheory.IndepFun f g μ)
Goal: ∫⁻ (ω : Ω), (f * g) ω ∂μ = (∫⁻ (ω : Ω), f ω ∂μ) * ∫⁻ (ω : Ω), g ω ∂μ
-- ProbabilityTheory.lintegral_mul_eq_lintegral_mul_lintegral_of_indepFun''
theorem lintegral_mul_eq_lintegral_mul_lintegral_of_indepFun'' (h_meas_f : AEMeasurable f μ)
    (h_meas_g : AEMeasurable g μ) (h_indep_fun : IndepFun f g μ) :
    ∫⁻ ω, f ω * g ω ∂μ = (∫⁻ ω, f ω ∂μ) * ∫⁻ ω, g ω ∂μ 
Arguments: {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {f g : Ω → ℝ≥0∞} (h_meas_f : AEMeasurable f μ) (h_meas_g : AEMeasurable g μ) (h_indep_fun : ProbabilityTheory.IndepFun f g μ)
Goal: ∫⁻ (ω : Ω), f ω * g ω ∂μ = (∫⁻ (ω : Ω), f ω ∂μ) * ∫⁻ (ω : Ω), g ω ∂μ
-- ProbabilityTheory.IndepFun.integrable_mul
theorem IndepFun.integrable_mul {β : Type*} [MeasurableSpace β] {X Y : Ω → β}
    [NormedDivisionRing β] [BorelSpace β] (hXY : IndepFun X Y μ) (hX : Integrable X μ)
    (hY : Integrable Y μ) : Integrable (X * Y) μ 
Arguments: {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {β : Type u_2} [MeasurableSpace β] {X Y : Ω → β} [NormedDivisionRing β] [BorelSpace β] (hXY : ProbabilityTheory.IndepFun X Y μ) (hX : MeasureTheory.Integrable X μ) (hY : MeasureTheory.Integrable Y μ)
Goal: MeasureTheory.Integrable (X * Y) μ
-- ProbabilityTheory.IndepFun.integrable_left_of_integrable_mul
theorem IndepFun.integrable_left_of_integrable_mul {β : Type*} [MeasurableSpace β] {X Y : Ω → β}
    [NormedDivisionRing β] [BorelSpace β] (hXY : IndepFun X Y μ) (h'XY : Integrable (X * Y) μ)
    (hX : AEStronglyMeasurable X μ) (hY : AEStronglyMeasurable Y μ) (h'Y : ¬Y =ᵐ[μ] 0) :
    Integrable X μ 
Arguments: {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {β : Type u_2} [MeasurableSpace β] {X Y : Ω → β} [NormedDivisionRing β] [BorelSpace β] (hXY : ProbabilityTheory.IndepFun X Y μ) (h'XY : MeasureTheory.Integrable (X * Y) μ) (hX : MeasureTheory.AEStronglyMeasurable X μ) (hY : MeasureTheory.AEStronglyMeasurable Y μ) (h'Y : ¬Y =ᵐ[μ] 0)
Goal: MeasureTheory.Integrable X μ
-- ProbabilityTheory.IndepFun.integrable_right_of_integrable_mul
theorem IndepFun.integrable_right_of_integrable_mul {β : Type*} [MeasurableSpace β] {X Y : Ω → β}
    [NormedDivisionRing β] [BorelSpace β] (hXY : IndepFun X Y μ) (h'XY : Integrable (X * Y) μ)
    (hX : AEStronglyMeasurable X μ) (hY : AEStronglyMeasurable Y μ) (h'X : ¬X =ᵐ[μ] 0) :
    Integrable Y μ 
Arguments: {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {β : Type u_2} [MeasurableSpace β] {X Y : Ω → β} [NormedDivisionRing β] [BorelSpace β] (hXY : ProbabilityTheory.IndepFun X Y μ) (h'XY : MeasureTheory.Integrable (X * Y) μ) (hX : MeasureTheory.AEStronglyMeasurable X μ) (hY : MeasureTheory.AEStronglyMeasurable Y μ) (h'X : ¬X =ᵐ[μ] 0)
Goal: MeasureTheory.Integrable Y μ
-- ProbabilityTheory.IndepFun.integral_mul_of_nonneg
theorem IndepFun.integral_mul_of_nonneg (hXY : IndepFun X Y μ) (hXp : 0 ≤ X) (hYp : 0 ≤ Y)
    (hXm : AEMeasurable X μ) (hYm : AEMeasurable Y μ) :
    integral μ (X * Y) = integral μ X * integral μ Y 
Arguments: {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {X Y : Ω → ℝ} (hXY : ProbabilityTheory.IndepFun X Y μ) (hXp : 0 ≤ X) (hYp : 0 ≤ Y) (hXm : AEMeasurable X μ) (hYm : AEMeasurable Y μ)
Goal: MeasureTheory.integral μ (X * Y) = MeasureTheory.integral μ X * MeasureTheory.integral μ Y
-- ProbabilityTheory.IndepFun.integral_mul_of_integrable
theorem IndepFun.integral_mul_of_integrable (hXY : IndepFun X Y μ) (hX : Integrable X μ)
    (hY : Integrable Y μ) : integral μ (X * Y) = integral μ X * integral μ Y 
Arguments: {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {X Y : Ω → ℝ} (hXY : ProbabilityTheory.IndepFun X Y μ) (hX : MeasureTheory.Integrable X μ) (hY : MeasureTheory.Integrable Y μ)
Goal: MeasureTheory.integral μ (X * Y) = MeasureTheory.integral μ X * MeasureTheory.integral μ Y
-- ProbabilityTheory.IndepFun.integral_mul
theorem IndepFun.integral_mul (hXY : IndepFun X Y μ) (hX : AEStronglyMeasurable X μ)
    (hY : AEStronglyMeasurable Y μ) : integral μ (X * Y) = integral μ X * integral μ Y 
Arguments: {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {X Y : Ω → ℝ} (hXY : ProbabilityTheory.IndepFun X Y μ) (hX : MeasureTheory.AEStronglyMeasurable X μ) (hY : MeasureTheory.AEStronglyMeasurable Y μ)
Goal: MeasureTheory.integral μ (X * Y) = MeasureTheory.integral μ X * MeasureTheory.integral μ Y
-- ProbabilityTheory.IndepFun.integral_mul'
theorem IndepFun.integral_mul' (hXY : IndepFun X Y μ) (hX : AEStronglyMeasurable X μ)
    (hY : AEStronglyMeasurable Y μ) :
    (integral μ fun ω => X ω * Y ω) = integral μ X * integral μ Y 
Arguments: {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {X Y : Ω → ℝ} (hXY : ProbabilityTheory.IndepFun X Y μ) (hX : MeasureTheory.AEStronglyMeasurable X μ) (hY : MeasureTheory.AEStronglyMeasurable Y μ)
Goal: ∫ (ω : Ω), X ω * Y ω ∂μ = MeasureTheory.integral μ X * MeasureTheory.integral μ Y
-- ProbabilityTheory.indepFun_iff_integral_comp_mul
theorem indepFun_iff_integral_comp_mul [IsFiniteMeasure μ] {β β' : Type*} {mβ : MeasurableSpace β}
    {mβ' : MeasurableSpace β'} {f : Ω → β} {g : Ω → β'} {hfm : Measurable f} {hgm : Measurable g} :
    IndepFun f g μ ↔ ∀ {φ : β → ℝ} {ψ : β' → ℝ}, Measurable φ → Measurable ψ →
      Integrable (φ ∘ f) μ → Integrable (ψ ∘ g) μ →
        integral μ (φ ∘ f * ψ ∘ g) = integral μ (φ ∘ f) * integral μ (ψ ∘ g) 
Arguments: {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} [MeasureTheory.IsFiniteMeasure μ] {β : Type u_2} {β' : Type u_3} {mβ : MeasurableSpace β} {mβ' : MeasurableSpace β'} {f : Ω → β} {g : Ω → β'} {hfm : Measurable f} {hgm : Measurable g}
Goal: ProbabilityTheory.IndepFun f g μ ↔
  ∀ {φ : β → ℝ} {ψ : β' → ℝ},
    Measurable φ →
      Measurable ψ →
        MeasureTheory.Integrable (φ ∘ f) μ →
          MeasureTheory.Integrable (ψ ∘ g) μ →
            MeasureTheory.integral μ (φ ∘ f * ψ ∘ g) =
              MeasureTheory.integral μ (φ ∘ f) * MeasureTheory.integral μ (ψ ∘ g)
-- AlgebraicGeometry.PresheafedSpace.GlueData.f_open
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
structure GlueData extends GlueData (PresheafedSpace.{u, v, v} C) where
  f_open : ∀ i j, IsOpenImmersion (f i j)
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (self : AlgebraicGeometry.PresheafedSpace.GlueData C) (i j : self.J)
Goal: AlgebraicGeometry.PresheafedSpace.IsOpenImmersion (self.f i j)
-- AlgebraicGeometry.PresheafedSpace.GlueData.ι_openEmbedding
theorem ι_openEmbedding [HasLimits C] (i : D.J) : OpenEmbedding (𝖣.ι i).base 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (D : AlgebraicGeometry.PresheafedSpace.GlueData C) [CategoryTheory.Limits.HasLimits C] (i : D.J)
Goal: OpenEmbedding ⇑(D.ι i).base
-- AlgebraicGeometry.PresheafedSpace.GlueData.pullback_base
theorem pullback_base (i j k : D.J) (S : Set (D.V (i, j)).carrier) :
    (π₂ i, j, k) '' ((π₁ i, j, k) ⁻¹' S) = D.f i k ⁻¹' (D.f i j '' S) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (D : AlgebraicGeometry.PresheafedSpace.GlueData C) (i j k : D.J) (S : Set ↑↑(D.V (i, j)))
Goal: ⇑(CategoryTheory.Limits.pullback.snd (D.f i j) (D.f i k)).base ''
    (⇑(CategoryTheory.Limits.pullback.fst (D.f i j) (D.f i k)).base ⁻¹' S) =
  ⇑(D.f i k).base ⁻¹' (⇑(D.f i j).base '' S)
-- AlgebraicGeometry.PresheafedSpace.GlueData.f_invApp_f_app
@[simp, reassoc]
theorem f_invApp_f_app (i j k : D.J) (U : Opens (D.V (i, j)).carrier) :
    (D.f_open i j).invApp U ≫ (D.f i k).c.app _ =
      (π₁ i, j, k).c.app (op U) ≫
        (π₂⁻¹ i, j, k) (unop _) ≫
          (D.V _).presheaf.map
            (eqToHom
              (by
                delta IsOpenImmersion.opensFunctor
                dsimp only [Functor.op, IsOpenMap.functor, Opens.map, unop_op]
                congr
                apply pullback_base)) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (D : AlgebraicGeometry.PresheafedSpace.GlueData C) (i j k : D.J) (U : TopologicalSpace.Opens ↑↑(D.V (i, j)))
Goal: AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.invApp (D.f i j) U ≫
    (D.f i k).c.app (Opposite.op ((AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.opensFunctor (D.f i j)).obj U)) =
  (CategoryTheory.Limits.pullback.fst (D.f i j) (D.f i k)).c.app (Opposite.op U) ≫
    AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.invApp (CategoryTheory.Limits.pullback.snd (D.f i j) (D.f i k))
        (Opposite.unop
          (Opposite.op
            ((TopologicalSpace.Opens.map (CategoryTheory.Limits.pullback.fst (D.f i j) (D.f i k)).base).toPrefunctor.1
              (Opposite.unop (Opposite.op U))))) ≫
      (D.V (i, k)).presheaf.map (CategoryTheory.eqToHom ⋯)
-- AlgebraicGeometry.PresheafedSpace.GlueData.snd_invApp_t_app'
theorem snd_invApp_t_app' (i j k : D.J) (U : Opens (pullback (D.f i j) (D.f i k)).carrier) :
    ∃ eq,
      (π₂⁻¹ i, j, k) U ≫ (D.t k i).c.app _ ≫ (D.V (k, i)).presheaf.map (eqToHom eq) =
        (D.t' k i j).c.app _ ≫ (π₁⁻¹ k, j, i) (unop _) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (D : AlgebraicGeometry.PresheafedSpace.GlueData C) (i j k : D.J) (U : TopologicalSpace.Opens ↑↑(CategoryTheory.Limits.pullback (D.f i j) (D.f i k)))
Goal: ∃ (eq :
  (TopologicalSpace.Opens.map (D.t k i).base).op.obj
      (Opposite.op
        ((AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.opensFunctor
              (CategoryTheory.Limits.pullback.snd (D.f i j) (D.f i k))).obj
          U)) =
    Opposite.op
      ((AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.opensFunctor
            (CategoryTheory.Limits.pullback.fst (D.f k i) (D.f k j))).obj
        (Opposite.unop
          (Opposite.op { carrier := ⇑(D.t' k i j).base ⁻¹' ↑(Opposite.unop (Opposite.op U)), is_open' := ⋯ })))),
  AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.invApp (CategoryTheory.Limits.pullback.snd (D.f i j) (D.f i k)) U ≫
      (D.t k i).c.app
          (Opposite.op
            ((AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.opensFunctor
                  (CategoryTheory.Limits.pullback.snd (D.f i j) (D.f i k))).obj
              U)) ≫
        (D.V (k, i)).presheaf.map (CategoryTheory.eqToHom eq) =
    (D.t' k i j).c.app (Opposite.op U) ≫
      AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.invApp (CategoryTheory.Limits.pullback.fst (D.f k i) (D.f k j))
        (Opposite.unop
          (Opposite.op { carrier := ⇑(D.t' k i j).base ⁻¹' ↑(Opposite.unop (Opposite.op U)), is_open' := ⋯ }))
-- AlgebraicGeometry.PresheafedSpace.GlueData.snd_invApp_t_app
@[simp, reassoc]
theorem snd_invApp_t_app (i j k : D.J) (U : Opens (pullback (D.f i j) (D.f i k)).carrier) :
    (π₂⁻¹ i, j, k) U ≫ (D.t k i).c.app _ =
      (D.t' k i j).c.app _ ≫
        (π₁⁻¹ k, j, i) (unop _) ≫
          (D.V (k, i)).presheaf.map (eqToHom (D.snd_invApp_t_app' i j k U).choose.symm) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (D : AlgebraicGeometry.PresheafedSpace.GlueData C) (i j k : D.J) (U : TopologicalSpace.Opens ↑↑(CategoryTheory.Limits.pullback (D.f i j) (D.f i k)))
Goal: AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.invApp (CategoryTheory.Limits.pullback.snd (D.f i j) (D.f i k)) U ≫
    (D.t k i).c.app
      (Opposite.op
        ((AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.opensFunctor
              (CategoryTheory.Limits.pullback.snd (D.f i j) (D.f i k))).obj
          U)) =
  (D.t' k i j).c.app (Opposite.op U) ≫
    AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.invApp (CategoryTheory.Limits.pullback.fst (D.f k i) (D.f k j))
        (Opposite.unop
          (Opposite.op { carrier := ⇑(D.t' k i j).base ⁻¹' ↑(Opposite.unop (Opposite.op U)), is_open' := ⋯ })) ≫
      (D.V (k, i)).presheaf.map (CategoryTheory.eqToHom ⋯)