fullname
stringlengths 2
164
| header
stringlengths 61
1.2k
| imported_modules
stringlengths 60
684
| opened_namespaces
stringlengths 1
1.07k
| formal_statement
stringlengths 12
18.2k
| formal_statement_original
stringlengths 23
18.2k
| formal_statement_references
stringlengths 0
5.33k
| formal_proof
stringlengths 0
11.8k
| formal_proof_references
stringlengths 0
18.2k
| doc_string
stringlengths 0
10.5k
| problem_id
stringclasses 1
value | problem_kind
stringclasses 2
values | informal_statement
stringclasses 1
value | informal_proof
stringclasses 1
value | ref
stringlengths 0
68
| inv_references
stringclasses 1
value | passed
stringclasses 2
values | module_name
stringlengths 25
90
| head
null | lean_toolchain
stringclasses 1
value | package_name
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
unitInterval.instMeasureSpaceElemReal | import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
open scoped unitInterval
open MeasureTheory
| import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
| open scoped unitInterval
open MeasureTheory
| noncomputable instance : MeasureSpace I := sorry | def instMeasureSpaceElemReal_extracted : MeasureSpace βI := sorry | [['unitInterval'], ['Set', 'Elem'], ['Real'], ['MeasureTheory', 'MeasureSpace']] | noncomputable instance : MeasureSpace I := Measure.Subtype.measureSpace | [['Membership', 'mem'], ['unitInterval'], ['Set'], ['Real'], ['Real', 'measureSpace'], ['Set', 'instMembership'], ['MeasureTheory', 'Measure', 'Subtype', 'measureSpace']] | theorem | Syntax(original=True, range=StringRange(start=587, stop=658)) | True | ['Mathlib', 'MeasureTheory', 'Constructions', 'UnitInterval'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
unitInterval.volume_def | import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
open scoped unitInterval
open MeasureTheory
| import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
| open scoped unitInterval
open MeasureTheory
| theorem volume_def : (volume : Measure I) = volume.comap Subtype.val := sorry | theorem volume_def_extracted : volume = Measure.comap Subtype.val volume := sorry | [['Membership', 'mem'], ['MeasureTheory', 'Measure'], ['MeasureTheory', 'MeasureSpace', 'toMeasurableSpace'], ['unitInterval'], ['Set', 'Elem'], ['Subtype', 'val'], ['MeasureTheory', 'Measure', 'comap'], ['Set'], ['Real'], ['Real', 'measureSpace'], ['unitInterval', 'instMeasureSpaceElemReal'], ['Set', 'instMembership'], ['MeasureTheory', 'MeasureSpace', 'volume'], ['Subtype'], ['Eq']] | theorem volume_def : (volume : Measure I) = volume.comap Subtype.val := rfl | [['MeasureTheory', 'Measure'], ['MeasureTheory', 'MeasureSpace', 'toMeasurableSpace'], ['unitInterval'], ['Set', 'Elem'], ['Real'], ['unitInterval', 'instMeasureSpaceElemReal'], ['MeasureTheory', 'MeasureSpace', 'volume'], ['rfl']] | theorem | Syntax(original=True, range=StringRange(start=660, stop=735)) | True | ['Mathlib', 'MeasureTheory', 'Constructions', 'UnitInterval'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
unitInterval.instIsProbabilityMeasureElemRealVolume | import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
open scoped unitInterval
open MeasureTheory
| import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
| open scoped unitInterval
open MeasureTheory
| instance : IsProbabilityMeasure (volume : Measure I) := sorry | def instIsProbabilityMeasureElemRealVolume_extracted : IsProbabilityMeasure volume := sorry | [['MeasureTheory', 'MeasureSpace', 'toMeasurableSpace'], ['unitInterval'], ['Set', 'Elem'], ['Real'], ['unitInterval', 'instMeasureSpaceElemReal'], ['MeasureTheory', 'IsProbabilityMeasure'], ['MeasureTheory', 'MeasureSpace', 'volume']] | instance : IsProbabilityMeasure (volume : Measure I) where
measure_univ := by
rw [Measure.Subtype.volume_univ measurableSet_Icc.nullMeasurableSet, Real.volume_Icc, sub_zero,
ENNReal.ofReal_one] | [['AddCommGroup', 'toDivisionAddCommMonoid'], ['Real', 'volume_Icc'], ['Real', 'borelSpace'], ['OfNat', 'ofNat'], ['Set', 'Icc'], ['Set'], ['Real'], ['ENNReal', 'ofReal'], ['Eq', 'refl'], ['MeasureTheory', 'Measure', 'instFunLike'], ['Real', 'instAddCommGroup'], ['unitInterval', 'instMeasureSpaceElemReal'], ['MeasureTheory', 'Measure', 'Subtype', 'measureSpace'], ['SubtractionCommMonoid', 'toSubtractionMonoid'], ['ENNReal', 'ofReal_one'], ['CanonicallyOrderedCommSemiring', 'toOne'], ['MeasureTheory', 'MeasureSpace', 'volume'], ['BorelSpace', 'opensMeasurable'], ['Eq'], ['MeasureTheory', 'IsProbabilityMeasure', 'mk'], ['MeasureTheory', 'Measure'], ['Zero', 'toOfNat0'], ['SubNegMonoid', 'toSub'], ['instOrderTopologyReal'], ['Real', 'linearOrder'], ['ENNReal'], ['OrderTopology', 'to_orderClosedTopology'], ['Eq', 'mpr'], ['Set', 'Elem'], ['sub_zero'], ['Real', 'measureSpace'], ['UniformSpace', 'toTopologicalSpace'], ['DFunLike', 'coe'], ['SubtractionMonoid', 'toSubNegZeroMonoid'], ['id'], ['instHSub'], ['Membership', 'mem'], ['measurableSet_Icc'], ['Real', 'instSub'], ['ENNReal', 'instCanonicallyOrderedCommSemiring'], ['HSub', 'hSub'], ['PseudoMetricSpace', 'toUniformSpace'], ['Real', 'pseudoMetricSpace'], ['Real', 'instZero'], ['One', 'toOfNat1'], ['Set', 'instMembership'], ['MeasurableSet', 'nullMeasurableSet'], ['SubNegZeroMonoid', 'toNegZeroClass'], ['Set', 'univ'], ['SubNegZeroMonoid', 'toSubNegMonoid'], ['MeasureTheory', 'MeasureSpace', 'toMeasurableSpace'], ['Real', 'instOne'], ['unitInterval'], ['Real', 'instPreorder'], ['NegZeroClass', 'toZero'], ['congrArg'], ['MeasureTheory', 'Measure', 'Subtype', 'volume_univ']] | theorem | Syntax(original=True, range=StringRange(start=737, stop=942)) | True | ['Mathlib', 'MeasureTheory', 'Constructions', 'UnitInterval'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
unitInterval.measurable_symm | import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
open scoped unitInterval
open MeasureTheory
| import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
| open scoped unitInterval
open MeasureTheory
| @[measurability]
theorem measurable_symm : Measurable symm := sorry | theorem measurable_symm_extracted : Measurable Ο := sorry | [['unitInterval', 'symm'], ['Membership', 'mem'], ['unitInterval'], ['Subtype', 'instMeasurableSpace'], ['Set', 'Elem'], ['Real', 'measurableSpace'], ['Set'], ['Real'], ['Measurable'], ['Set', 'instMembership']] | @[measurability]
theorem measurable_symm : Measurable symm := continuous_symm.measurable | [['Membership', 'mem'], ['Real', 'borelSpace'], ['Subtype', 'instMeasurableSpace'], ['Real'], ['Set'], ['Real', 'measurableSpace'], ['PseudoMetricSpace', 'toUniformSpace'], ['Real', 'pseudoMetricSpace'], ['Set', 'instMembership'], ['Subtype', 'borelSpace'], ['BorelSpace', 'opensMeasurable'], ['unitInterval', 'symm'], ['Continuous', 'measurable'], ['unitInterval'], ['Set', 'Elem'], ['unitInterval', 'continuous_symm'], ['Subtype', 'opensMeasurableSpace'], ['instTopologicalSpaceSubtype'], ['UniformSpace', 'toTopologicalSpace']] | theorem | Syntax(original=True, range=StringRange(start=944, stop=1032)) | True | ['Mathlib', 'MeasureTheory', 'Constructions', 'UnitInterval'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
unitInterval.instIsProbabilityMeasureElemRealVolume_tac_814 | import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
open scoped unitInterval
open MeasureTheory
| import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
| open scoped unitInterval
open MeasureTheory
| lemma instIsProbabilityMeasureElemRealVolume_tac_814 : volume Set.univ = 1 := sorry | lemma instIsProbabilityMeasureElemRealVolume_tac_814 : volume Set.univ = 1 := sorry | [['Real', 'volume_Icc'], ['measurableSet_Icc', 'nullMeasurableSet'], ['sub_zero'], ['Measure', 'Subtype', 'volume_univ'], ['ENNReal', 'ofReal_one']] | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'UnitInterval'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||||||
unitInterval.instIsProbabilityMeasureElemRealVolume_tac_814 | import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
open scoped unitInterval
open MeasureTheory
| import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
| open scoped unitInterval
open MeasureTheory
| lemma instIsProbabilityMeasureElemRealVolume_tac_814 : volume Set.univ = 1 := sorry | lemma instIsProbabilityMeasureElemRealVolume_tac_814 : volume Set.univ = 1 := sorry | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'UnitInterval'] | null | leanprover/lean4:v4.11.0
| Mathlib |
||||||||||
unitInterval.instIsProbabilityMeasureElemRealVolume_tac_821 | import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
open scoped unitInterval
open MeasureTheory
| import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
| open scoped unitInterval
open MeasureTheory
| lemma instIsProbabilityMeasureElemRealVolume_tac_821 : volume Set.univ = 1 := sorry | lemma instIsProbabilityMeasureElemRealVolume_tac_821 : volume Set.univ = 1 := sorry | [['Real', 'volume_Icc'], ['measurableSet_Icc', 'nullMeasurableSet'], ['sub_zero'], ['Measure', 'Subtype', 'volume_univ'], ['ENNReal', 'ofReal_one']] | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'UnitInterval'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||||||
unitInterval.instIsProbabilityMeasureElemRealVolume_tac_821 | import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
open scoped unitInterval
open MeasureTheory
| import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
| open scoped unitInterval
open MeasureTheory
| lemma instIsProbabilityMeasureElemRealVolume_tac_821 : volume Set.univ = 1 := sorry | lemma instIsProbabilityMeasureElemRealVolume_tac_821 : volume Set.univ = 1 := sorry | [['Real', 'volume_Icc'], ['measurableSet_Icc', 'nullMeasurableSet'], ['sub_zero'], ['Measure', 'Subtype', 'volume_univ'], ['ENNReal', 'ofReal_one']] | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'UnitInterval'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||||||
unitInterval.instIsProbabilityMeasureElemRealVolume_tac_821 | import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
open scoped unitInterval
open MeasureTheory
| import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
| open scoped unitInterval
open MeasureTheory
| lemma instIsProbabilityMeasureElemRealVolume_tac_821 : volume Set.univ = 1 := sorry | lemma instIsProbabilityMeasureElemRealVolume_tac_821 : volume Set.univ = 1 := sorry | [['Real', 'volume_Icc'], ['measurableSet_Icc', 'nullMeasurableSet'], ['sub_zero'], ['Measure', 'Subtype', 'volume_univ'], ['ENNReal', 'ofReal_one']] | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'UnitInterval'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||||||
unitInterval.instIsProbabilityMeasureElemRealVolume_tac_821 | import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
open scoped unitInterval
open MeasureTheory
| import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
| open scoped unitInterval
open MeasureTheory
| lemma instIsProbabilityMeasureElemRealVolume_tac_821 : volume Set.univ = 1 := sorry | lemma instIsProbabilityMeasureElemRealVolume_tac_821 : volume Set.univ = 1 := sorry | [['Real', 'volume_Icc'], ['measurableSet_Icc', 'nullMeasurableSet'], ['sub_zero'], ['Measure', 'Subtype', 'volume_univ'], ['ENNReal', 'ofReal_one']] | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'UnitInterval'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||||||
unitInterval.instIsProbabilityMeasureElemRealVolume_tac_821 | import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
open scoped unitInterval
open MeasureTheory
| import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
| open scoped unitInterval
open MeasureTheory
| lemma instIsProbabilityMeasureElemRealVolume_tac_821 : volume Set.univ = 1 := sorry | lemma instIsProbabilityMeasureElemRealVolume_tac_821 : volume Set.univ = 1 := sorry | [['Real', 'volume_Icc'], ['measurableSet_Icc', 'nullMeasurableSet'], ['sub_zero'], ['Measure', 'Subtype', 'volume_univ'], ['ENNReal', 'ofReal_one']] | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'UnitInterval'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||||||
unitInterval.instIsProbabilityMeasureElemRealVolume_tac_821 | import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
open scoped unitInterval
open MeasureTheory
| import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
| open scoped unitInterval
open MeasureTheory
| lemma instIsProbabilityMeasureElemRealVolume_tac_821 : volume Set.univ = 1 := sorry | lemma instIsProbabilityMeasureElemRealVolume_tac_821 : volume Set.univ = 1 := sorry | [['Real', 'volume_Icc'], ['measurableSet_Icc', 'nullMeasurableSet'], ['sub_zero'], ['Measure', 'Subtype', 'volume_univ'], ['ENNReal', 'ofReal_one']] | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'UnitInterval'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||||||
unitInterval.instIsProbabilityMeasureElemRealVolume_tac_821 | import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
open scoped unitInterval
open MeasureTheory
| import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
| open scoped unitInterval
open MeasureTheory
| lemma instIsProbabilityMeasureElemRealVolume_tac_821 : volume Set.univ = 1 := sorry | lemma instIsProbabilityMeasureElemRealVolume_tac_821 : volume Set.univ = 1 := sorry | [['Real', 'volume_Icc'], ['measurableSet_Icc', 'nullMeasurableSet'], ['sub_zero'], ['Measure', 'Subtype', 'volume_univ'], ['ENNReal', 'ofReal_one']] | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'UnitInterval'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||||||
unitInterval.instIsProbabilityMeasureElemRealVolume_tac_821 | import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
open scoped unitInterval
open MeasureTheory
| import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
| open scoped unitInterval
open MeasureTheory
| lemma instIsProbabilityMeasureElemRealVolume_tac_821 : volume Set.univ = 1 := sorry | lemma instIsProbabilityMeasureElemRealVolume_tac_821 : volume Set.univ = 1 := sorry | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'UnitInterval'] | null | leanprover/lean4:v4.11.0
| Mathlib |
||||||||||
unitInterval.instIsProbabilityMeasureElemRealVolume_tac_825 | import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
open scoped unitInterval
open MeasureTheory
| import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
| open scoped unitInterval
open MeasureTheory
| lemma instIsProbabilityMeasureElemRealVolume_tac_825 : volume Set.univ = 1 := sorry | lemma instIsProbabilityMeasureElemRealVolume_tac_825 : volume Set.univ = 1 := sorry | [['measurableSet_Icc', 'nullMeasurableSet'], ['Measure', 'Subtype', 'volume_univ']] | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'UnitInterval'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||||||
unitInterval.instIsProbabilityMeasureElemRealVolume_tac_890 | import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
open scoped unitInterval
open MeasureTheory
| import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
| open scoped unitInterval
open MeasureTheory
| lemma instIsProbabilityMeasureElemRealVolume_tac_890 : volume (Set.Icc 0 1) = 1 := sorry | lemma instIsProbabilityMeasureElemRealVolume_tac_890 : volume (Set.Icc 0 1) = 1 := sorry | [['Real', 'volume_Icc']] | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'UnitInterval'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||||||
unitInterval.instIsProbabilityMeasureElemRealVolume_tac_907 | import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
open scoped unitInterval
open MeasureTheory
| import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
| open scoped unitInterval
open MeasureTheory
| lemma instIsProbabilityMeasureElemRealVolume_tac_907 : ENNReal.ofReal (1 - 0) = 1 := sorry | lemma instIsProbabilityMeasureElemRealVolume_tac_907 : ENNReal.ofReal (1 - 0) = 1 := sorry | [['sub_zero']] | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'UnitInterval'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||||||
unitInterval.instIsProbabilityMeasureElemRealVolume_tac_923 | import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
open scoped unitInterval
open MeasureTheory
| import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
| open scoped unitInterval
open MeasureTheory
| lemma instIsProbabilityMeasureElemRealVolume_tac_923 : ENNReal.ofReal 1 = 1 := sorry | lemma instIsProbabilityMeasureElemRealVolume_tac_923 : ENNReal.ofReal 1 = 1 := sorry | [['ENNReal', 'ofReal_one']] | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'UnitInterval'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||||||
unitInterval.instIsProbabilityMeasureElemRealVolume_tac_821 | import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
open scoped unitInterval
open MeasureTheory
| import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
| open scoped unitInterval
open MeasureTheory
| lemma instIsProbabilityMeasureElemRealVolume_tac_821 : 1 = 1 := sorry | lemma instIsProbabilityMeasureElemRealVolume_tac_821 : 1 = 1 := sorry | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'UnitInterval'] | null | leanprover/lean4:v4.11.0
| Mathlib |
||||||||||
unitInterval.instIsProbabilityMeasureElemRealVolume_tac_821 | import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
open scoped unitInterval
open MeasureTheory
| import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
| open scoped unitInterval
open MeasureTheory
| lemma instIsProbabilityMeasureElemRealVolume_tac_821 : 1 = 1 := sorry | lemma instIsProbabilityMeasureElemRealVolume_tac_821 : 1 = 1 := sorry | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'UnitInterval'] | null | leanprover/lean4:v4.11.0
| Mathlib |
||||||||||
unitInterval.instIsProbabilityMeasureElemRealVolume_tac_941 | import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
open scoped unitInterval
open MeasureTheory
| import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
| open scoped unitInterval
open MeasureTheory
| lemma instIsProbabilityMeasureElemRealVolume_tac_941 : 1 = 1 := sorry | lemma instIsProbabilityMeasureElemRealVolume_tac_941 : 1 = 1 := sorry | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'UnitInterval'] | null | leanprover/lean4:v4.11.0
| Mathlib |
||||||||||
unitInterval.instIsProbabilityMeasureElemRealVolume_tac_821 | import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
open scoped unitInterval
open MeasureTheory
| import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
| open scoped unitInterval
open MeasureTheory
| lemma instIsProbabilityMeasureElemRealVolume_tac_821 : 1 = 1 := sorry | lemma instIsProbabilityMeasureElemRealVolume_tac_821 : 1 = 1 := sorry | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'UnitInterval'] | null | leanprover/lean4:v4.11.0
| Mathlib |
||||||||||
unitInterval.instIsProbabilityMeasureElemRealVolume_tac_821 | import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
open scoped unitInterval
open MeasureTheory
| import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
| open scoped unitInterval
open MeasureTheory
| lemma instIsProbabilityMeasureElemRealVolume_tac_821 : 1 = 1 := sorry | lemma instIsProbabilityMeasureElemRealVolume_tac_821 : 1 = 1 := sorry | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'UnitInterval'] | null | leanprover/lean4:v4.11.0
| Mathlib |
||||||||||
unitInterval.instIsProbabilityMeasureElemRealVolume_tac_821 | import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
open scoped unitInterval
open MeasureTheory
| import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
| open scoped unitInterval
open MeasureTheory
| lemma instIsProbabilityMeasureElemRealVolume_tac_821 : 1 = 1 := sorry | lemma instIsProbabilityMeasureElemRealVolume_tac_821 : 1 = 1 := sorry | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'UnitInterval'] | null | leanprover/lean4:v4.11.0
| Mathlib |
||||||||||
unitInterval.instIsProbabilityMeasureElemRealVolume_tac_821 | import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
open scoped unitInterval
open MeasureTheory
| import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
| open scoped unitInterval
open MeasureTheory
| lemma instIsProbabilityMeasureElemRealVolume_tac_821 : 1 = 1 := sorry | lemma instIsProbabilityMeasureElemRealVolume_tac_821 : 1 = 1 := sorry | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'UnitInterval'] | null | leanprover/lean4:v4.11.0
| Mathlib |
||||||||||
unitInterval.instIsProbabilityMeasureElemRealVolume_tac_821 | import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
open scoped unitInterval
open MeasureTheory
| import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
| open scoped unitInterval
open MeasureTheory
| lemma instIsProbabilityMeasureElemRealVolume_tac_821 : 1 = 1 := sorry | lemma instIsProbabilityMeasureElemRealVolume_tac_821 : 1 = 1 := sorry | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'UnitInterval'] | null | leanprover/lean4:v4.11.0
| Mathlib |
||||||||||
unitInterval.instIsProbabilityMeasureElemRealVolume_tac_821 | import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
open scoped unitInterval
open MeasureTheory
| import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
| open scoped unitInterval
open MeasureTheory
| lemma instIsProbabilityMeasureElemRealVolume_tac_821 : 1 = 1 := sorry | lemma instIsProbabilityMeasureElemRealVolume_tac_821 : 1 = 1 := sorry | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'UnitInterval'] | null | leanprover/lean4:v4.11.0
| Mathlib |
||||||||||
unitInterval.instIsProbabilityMeasureElemRealVolume_tac_821 | import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
open scoped unitInterval
open MeasureTheory
| import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
| open scoped unitInterval
open MeasureTheory
| lemma instIsProbabilityMeasureElemRealVolume_tac_821 : 1 = 1 := sorry | lemma instIsProbabilityMeasureElemRealVolume_tac_821 : 1 = 1 := sorry | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'UnitInterval'] | null | leanprover/lean4:v4.11.0
| Mathlib |
||||||||||
unitInterval.instIsProbabilityMeasureElemRealVolume_tac_821 | import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
open scoped unitInterval
open MeasureTheory
| import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
| open scoped unitInterval
open MeasureTheory
| lemma instIsProbabilityMeasureElemRealVolume_tac_821 : 1 = 1 := sorry | lemma instIsProbabilityMeasureElemRealVolume_tac_821 : 1 = 1 := sorry | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'UnitInterval'] | null | leanprover/lean4:v4.11.0
| Mathlib |
||||||||||
unitInterval.instIsProbabilityMeasureElemRealVolume_tac_821 | import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
open scoped unitInterval
open MeasureTheory
| import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
| open scoped unitInterval
open MeasureTheory
| lemma instIsProbabilityMeasureElemRealVolume_tac_821 : 1 = 1 := sorry | lemma instIsProbabilityMeasureElemRealVolume_tac_821 : 1 = 1 := sorry | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'UnitInterval'] | null | leanprover/lean4:v4.11.0
| Mathlib |
||||||||||
unitInterval.instIsProbabilityMeasureElemRealVolume_tac_821 | import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
open scoped unitInterval
open MeasureTheory
| import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
| open scoped unitInterval
open MeasureTheory
| lemma instIsProbabilityMeasureElemRealVolume_tac_821 : 1 = 1 := sorry | lemma instIsProbabilityMeasureElemRealVolume_tac_821 : 1 = 1 := sorry | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'UnitInterval'] | null | leanprover/lean4:v4.11.0
| Mathlib |
||||||||||
unitInterval.instIsProbabilityMeasureElemRealVolume_tac_821 | import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
open scoped unitInterval
open MeasureTheory
| import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
| open scoped unitInterval
open MeasureTheory
| lemma instIsProbabilityMeasureElemRealVolume_tac_821 : 1 = 1 := sorry | lemma instIsProbabilityMeasureElemRealVolume_tac_821 : 1 = 1 := sorry | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'UnitInterval'] | null | leanprover/lean4:v4.11.0
| Mathlib |
||||||||||
unitInterval.instIsProbabilityMeasureElemRealVolume_tac_821 | import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
open scoped unitInterval
open MeasureTheory
| import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
| open scoped unitInterval
open MeasureTheory
| lemma instIsProbabilityMeasureElemRealVolume_tac_821 : 1 = 1 := sorry | lemma instIsProbabilityMeasureElemRealVolume_tac_821 : 1 = 1 := sorry | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'UnitInterval'] | null | leanprover/lean4:v4.11.0
| Mathlib |
||||||||||
unitInterval.instIsProbabilityMeasureElemRealVolume_tac_821 | import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
open scoped unitInterval
open MeasureTheory
| import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
| open scoped unitInterval
open MeasureTheory
| lemma instIsProbabilityMeasureElemRealVolume_tac_821 : 1 = 1 := sorry | lemma instIsProbabilityMeasureElemRealVolume_tac_821 : 1 = 1 := sorry | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'UnitInterval'] | null | leanprover/lean4:v4.11.0
| Mathlib |
||||||||||
unitInterval.instIsProbabilityMeasureElemRealVolume_tac_821 | import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
open scoped unitInterval
open MeasureTheory
| import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
| open scoped unitInterval
open MeasureTheory
| lemma instIsProbabilityMeasureElemRealVolume_tac_821 : 1 = 1 := sorry | lemma instIsProbabilityMeasureElemRealVolume_tac_821 : 1 = 1 := sorry | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'UnitInterval'] | null | leanprover/lean4:v4.11.0
| Mathlib |
||||||||||
unitInterval.instIsProbabilityMeasureElemRealVolume_tac_821 | import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
open scoped unitInterval
open MeasureTheory
| import Init
import Mathlib.Topology.UnitInterval
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Constructions.UnitInterval
| open scoped unitInterval
open MeasureTheory
| lemma instIsProbabilityMeasureElemRealVolume_tac_821 : 1 = 1 := sorry | lemma instIsProbabilityMeasureElemRealVolume_tac_821 : 1 = 1 := sorry | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'UnitInterval'] | null | leanprover/lean4:v4.11.0
| Mathlib |
||||||||||
RCLike.measurableSpace | import Init
import Mathlib.Analysis.Complex.Basic
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Constructions.BorelSpace.Complex
| import Init
import Mathlib.Analysis.Complex.Basic
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Constructions.BorelSpace.Complex
| instance (priority := 900) RCLike.measurableSpace {π : Type*} [RCLike π] : MeasurableSpace π := sorry | def measurableSpace_extracted : {π : Type u_1} β [inst : RCLike π] β MeasurableSpace π := sorry | [['MeasurableSpace']] | instance (priority := 900) RCLike.measurableSpace {π : Type*} [RCLike π] : MeasurableSpace π :=
borel π | [['NormedCommRing', 'toSeminormedCommRing'], ['RCLike', 'toDenselyNormedField'], ['SeminormedCommRing', 'toSeminormedRing'], ['borel'], ['PseudoMetricSpace', 'toUniformSpace'], ['SeminormedRing', 'toPseudoMetricSpace'], ['DenselyNormedField', 'toNormedField'], ['NormedField', 'toNormedCommRing'], ['UniformSpace', 'toTopologicalSpace']] | theorem | Syntax(original=True, range=StringRange(start=330, stop=447)) | True | ['Mathlib', 'MeasureTheory', 'Constructions', 'BorelSpace', 'Complex'] | null | leanprover/lean4:v4.11.0
| Mathlib |
||||||
RCLike.borelSpace | import Init
import Mathlib.Analysis.Complex.Basic
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Constructions.BorelSpace.Complex
| import Init
import Mathlib.Analysis.Complex.Basic
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Constructions.BorelSpace.Complex
| instance (priority := 900) RCLike.borelSpace {π : Type*} [RCLike π] : BorelSpace π := sorry | def borelSpace_extracted : β {π : Type u_1} [inst : RCLike π], BorelSpace π := sorry | [['NormedCommRing', 'toSeminormedCommRing'], ['RCLike', 'toDenselyNormedField'], ['SeminormedCommRing', 'toSeminormedRing'], ['BorelSpace'], ['PseudoMetricSpace', 'toUniformSpace'], ['SeminormedRing', 'toPseudoMetricSpace'], ['DenselyNormedField', 'toNormedField'], ['RCLike', 'measurableSpace'], ['NormedField', 'toNormedCommRing'], ['UniformSpace', 'toTopologicalSpace']] | instance (priority := 900) RCLike.borelSpace {π : Type*} [RCLike π] : BorelSpace π :=
β¨rflβ© | [['NormedCommRing', 'toSeminormedCommRing'], ['RCLike', 'toDenselyNormedField'], ['SeminormedCommRing', 'toSeminormedRing'], ['BorelSpace', 'mk'], ['PseudoMetricSpace', 'toUniformSpace'], ['SeminormedRing', 'toPseudoMetricSpace'], ['DenselyNormedField', 'toNormedField'], ['RCLike', 'measurableSpace'], ['NormedField', 'toNormedCommRing'], ['UniformSpace', 'toTopologicalSpace'], ['MeasurableSpace'], ['rfl']] | theorem | Syntax(original=True, range=StringRange(start=449, stop=555)) | True | ['Mathlib', 'MeasureTheory', 'Constructions', 'BorelSpace', 'Complex'] | null | leanprover/lean4:v4.11.0
| Mathlib |
||||||
Complex.measurableSpace | import Init
import Mathlib.Analysis.Complex.Basic
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Constructions.BorelSpace.Complex
| import Init
import Mathlib.Analysis.Complex.Basic
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Constructions.BorelSpace.Complex
| instance Complex.measurableSpace : MeasurableSpace β := sorry | def measurableSpace_extracted : MeasurableSpace β := sorry | [['Complex'], ['MeasurableSpace']] | instance Complex.measurableSpace : MeasurableSpace β :=
borel β | [['NormedCommRing', 'toSeminormedCommRing'], ['SeminormedCommRing', 'toSeminormedRing'], ['Complex', 'instNormedField'], ['borel'], ['PseudoMetricSpace', 'toUniformSpace'], ['SeminormedRing', 'toPseudoMetricSpace'], ['Complex'], ['NormedField', 'toNormedCommRing'], ['UniformSpace', 'toTopologicalSpace']] | theorem | Syntax(original=True, range=StringRange(start=557, stop=626)) | True | ['Mathlib', 'MeasureTheory', 'Constructions', 'BorelSpace', 'Complex'] | null | leanprover/lean4:v4.11.0
| Mathlib |
||||||
Complex.borelSpace | import Init
import Mathlib.Analysis.Complex.Basic
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Constructions.BorelSpace.Complex
| import Init
import Mathlib.Analysis.Complex.Basic
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Constructions.BorelSpace.Complex
| instance Complex.borelSpace : BorelSpace β := sorry | def borelSpace_extracted : BorelSpace β := sorry | [['NormedCommRing', 'toSeminormedCommRing'], ['SeminormedCommRing', 'toSeminormedRing'], ['BorelSpace'], ['Complex', 'instNormedField'], ['Complex', 'measurableSpace'], ['PseudoMetricSpace', 'toUniformSpace'], ['SeminormedRing', 'toPseudoMetricSpace'], ['Complex'], ['NormedField', 'toNormedCommRing'], ['UniformSpace', 'toTopologicalSpace']] | instance Complex.borelSpace : BorelSpace β :=
β¨rflβ© | [['NormedCommRing', 'toSeminormedCommRing'], ['SeminormedCommRing', 'toSeminormedRing'], ['BorelSpace', 'mk'], ['Complex', 'instNormedField'], ['Complex', 'measurableSpace'], ['PseudoMetricSpace', 'toUniformSpace'], ['SeminormedRing', 'toPseudoMetricSpace'], ['Complex'], ['NormedField', 'toNormedCommRing'], ['UniformSpace', 'toTopologicalSpace'], ['MeasurableSpace'], ['rfl']] | theorem | Syntax(original=True, range=StringRange(start=628, stop=687)) | True | ['Mathlib', 'MeasureTheory', 'Constructions', 'BorelSpace', 'Complex'] | null | leanprover/lean4:v4.11.0
| Mathlib |
||||||
EventuallyMeasurableSpace | import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
open Filter Set MeasurableSpace
| import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
| open Filter Set MeasurableSpace
| /-- The `MeasurableSpace` of sets which are measurable with respect to a given Ο-algebra `m`
on `Ξ±`, modulo a given Ο-filter `l` on `Ξ±`. -/
def EventuallyMeasurableSpace (l : Filter Ξ±) [CountableInterFilter l] : MeasurableSpace Ξ± := sorry | def EventuallyMeasurableSpace_extracted : {Ξ± : Type u_1} β MeasurableSpace Ξ± β (l : Filter Ξ±) β [inst : CountableInterFilter l] β MeasurableSpace Ξ± := sorry | [['MeasurableSpace']] | /-- The `MeasurableSpace` of sets which are measurable with respect to a given Ο-algebra `m`
on `Ξ±`, modulo a given Ο-filter `l` on `Ξ±`. -/
def EventuallyMeasurableSpace (l : Filter Ξ±) [CountableInterFilter l] : MeasurableSpace Ξ± where
MeasurableSet' s := β t, MeasurableSet t β§ s =αΆ [l] t
measurableSet_empty := β¨β
, MeasurableSet.empty, EventuallyEq.refl _ _ β©
measurableSet_compl := fun s β¨t, ht, htsβ© => β¨tαΆ, ht.compl, hts.complβ©
measurableSet_iUnion s hs := by
choose t ht hts using hs
exact β¨β i, t i, MeasurableSet.iUnion ht, EventuallyEq.countable_iUnion htsβ© | [['And'], ['Exists'], ['Filter', 'EventuallyEq'], ['Set'], ['MeasurableSet'], ['EventuallyMeasurableSpace', 'proof_3'], ['MeasurableSpace', 'mk'], ['EventuallyMeasurableSpace', 'proof_1'], ['EventuallyMeasurableSpace', 'proof_2']] | The `MeasurableSpace` of sets which are measurable with respect to a given Ο-algebra `m`
on `Ξ±`, modulo a given Ο-filter `l` on `Ξ±`. | theorem | Syntax(original=True, range=StringRange(start=1392, stop=2007)) | True | ['Mathlib', 'MeasureTheory', 'Constructions', 'EventuallyMeasurable'] | null | leanprover/lean4:v4.11.0
| Mathlib |
||||
EventuallyMeasurableSet | import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
open Filter Set MeasurableSpace
| import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
| open Filter Set MeasurableSpace
| /-- We say a set `s` is an `EventuallyMeasurableSet` with respect to a given
Ο-algebra `m` and Ο-filter `l` if it differs from a set in `m` by a set in
the dual ideal of `l`. -/
def EventuallyMeasurableSet (l : Filter Ξ±) [CountableInterFilter l] (s : Set Ξ±) : Prop := sorry | def EventuallyMeasurableSet_extracted : {Ξ± : Type u_1} β MeasurableSpace Ξ± β (l : Filter Ξ±) β [inst : CountableInterFilter l] β Set Ξ± β Prop := sorry | /-- We say a set `s` is an `EventuallyMeasurableSet` with respect to a given
Ο-algebra `m` and Ο-filter `l` if it differs from a set in `m` by a set in
the dual ideal of `l`. -/
def EventuallyMeasurableSet (l : Filter Ξ±) [CountableInterFilter l] (s : Set Ξ±) : Prop :=
@MeasurableSet _ (EventuallyMeasurableSpace m l) s | [['EventuallyMeasurableSpace'], ['MeasurableSet']] | We say a set `s` is an `EventuallyMeasurableSet` with respect to a given
Ο-algebra `m` and Ο-filter `l` if it differs from a set in `m` by a set in
the dual ideal of `l`. | theorem | Syntax(original=True, range=StringRange(start=2009, stop=2334)) | True | ['Mathlib', 'MeasureTheory', 'Constructions', 'EventuallyMeasurable'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
MeasurableSet.eventuallyMeasurableSet | import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
open Filter Set MeasurableSpace
| import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
| open Filter Set MeasurableSpace
| theorem MeasurableSet.eventuallyMeasurableSet (hs : MeasurableSet s) :
EventuallyMeasurableSet m l s := sorry | theorem eventuallyMeasurableSet_extracted : β {Ξ± : Type u_1} {m : MeasurableSpace Ξ±} {s : Set Ξ±} {l : Filter Ξ±} [inst : CountableInterFilter l],
MeasurableSet s β EventuallyMeasurableSet m l s := sorry | [['EventuallyMeasurableSet']] | theorem MeasurableSet.eventuallyMeasurableSet (hs : MeasurableSet s) :
EventuallyMeasurableSet m l s :=
β¨s, hs, EventuallyEq.refl _ _β© | [['And'], ['Filter', 'EventuallyEq'], ['Filter', 'EventuallyEq', 'refl'], ['Set'], ['MeasurableSet'], ['And', 'intro'], ['Exists', 'intro']] | theorem | Syntax(original=True, range=StringRange(start=2400, stop=2544)) | True | ['Mathlib', 'MeasureTheory', 'Constructions', 'EventuallyMeasurable'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
EventuallyMeasurableSpace.measurable_le | import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
open Filter Set MeasurableSpace
| import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
| open Filter Set MeasurableSpace
| theorem EventuallyMeasurableSpace.measurable_le : m β€ EventuallyMeasurableSpace m l := sorry | theorem measurable_le_extracted : β {Ξ± : Type u_1} {m : MeasurableSpace Ξ±} {l : Filter Ξ±} [inst : CountableInterFilter l],
m β€ EventuallyMeasurableSpace m l := sorry | [['EventuallyMeasurableSpace'], ['MeasurableSpace', 'instLE'], ['MeasurableSpace'], ['LE', 'le']] | theorem EventuallyMeasurableSpace.measurable_le : m β€ EventuallyMeasurableSpace m l :=
fun _ hs => hs.eventuallyMeasurableSet | [['MeasurableSet', 'eventuallyMeasurableSet']] | theorem | Syntax(original=True, range=StringRange(start=2546, stop=2675)) | True | ['Mathlib', 'MeasureTheory', 'Constructions', 'EventuallyMeasurable'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
eventuallyMeasurableSet_of_mem_filter | import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
open Filter Set MeasurableSpace
| import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
| open Filter Set MeasurableSpace
| theorem eventuallyMeasurableSet_of_mem_filter (hs : s β l) : EventuallyMeasurableSet m l s := sorry | theorem eventuallyMeasurableSet_of_mem_filter_extracted : β {Ξ± : Type u_1} {m : MeasurableSpace Ξ±} {s : Set Ξ±} {l : Filter Ξ±} [inst : CountableInterFilter l],
s β l β EventuallyMeasurableSet m l s := sorry | [['EventuallyMeasurableSet']] | theorem eventuallyMeasurableSet_of_mem_filter (hs : s β l) : EventuallyMeasurableSet m l s :=
β¨univ, MeasurableSet.univ, eventuallyEq_univ.mpr hsβ© | [['Membership', 'mem'], ['MeasurableSet', 'univ'], ['And'], ['Filter', 'EventuallyEq'], ['Set'], ['MeasurableSet'], ['Filter'], ['And', 'intro'], ['Exists', 'intro'], ['Filter', 'eventuallyEq_univ'], ['Set', 'univ'], ['Iff', 'mpr'], ['instMembershipSetFilter']] | theorem | Syntax(original=True, range=StringRange(start=2677, stop=2831)) | True | ['Mathlib', 'MeasureTheory', 'Constructions', 'EventuallyMeasurable'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
EventuallyMeasurableSet.congr | import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
open Filter Set MeasurableSpace
| import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
| open Filter Set MeasurableSpace
| /-- A set which is `EventuallyEq` to an `EventuallyMeasurableSet`
is an `EventuallyMeasurableSet`. -/
theorem EventuallyMeasurableSet.congr
(ht : EventuallyMeasurableSet m l t) (hst : s =αΆ [l] t) : EventuallyMeasurableSet m l s := sorry | theorem congr_extracted : β {Ξ± : Type u_1} {m : MeasurableSpace Ξ±} {s t : Set Ξ±} {l : Filter Ξ±} [inst : CountableInterFilter l],
EventuallyMeasurableSet m l t β s =αΆ [l] t β EventuallyMeasurableSet m l s := sorry | [['EventuallyMeasurableSet']] | /-- A set which is `EventuallyEq` to an `EventuallyMeasurableSet`
is an `EventuallyMeasurableSet`. -/
theorem EventuallyMeasurableSet.congr
(ht : EventuallyMeasurableSet m l t) (hst : s =αΆ [l] t) : EventuallyMeasurableSet m l s := by
rcases ht with β¨t', ht', htt'β©
exact β¨t', ht', hst.trans htt'β© | [['And'], ['Filter', 'EventuallyEq'], ['Set'], ['MeasurableSet'], ['Filter', 'EventuallyEq', 'trans'], ['And', 'intro'], ['Exists', 'intro'], ['And', 'casesOn'], ['EventuallyMeasurableSet'], ['Exists', 'casesOn']] | A set which is `EventuallyEq` to an `EventuallyMeasurableSet`
is an `EventuallyMeasurableSet`. | theorem | Syntax(original=True, range=StringRange(start=2833, stop=3146)) | True | ['Mathlib', 'MeasureTheory', 'Constructions', 'EventuallyMeasurable'] | null | leanprover/lean4:v4.11.0
| Mathlib |
||||
EventuallyMeasurableSpace.measurableSingleton | import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
open Filter Set MeasurableSpace
| import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
| open Filter Set MeasurableSpace
| instance measurableSingleton [MeasurableSingletonClass Ξ±] :
@MeasurableSingletonClass Ξ± (EventuallyMeasurableSpace m l) := sorry | def measurableSingleton_extracted : β {Ξ± : Type u_1} {m : MeasurableSpace Ξ±} {l : Filter Ξ±} [inst : CountableInterFilter l]
[inst_1 : MeasurableSingletonClass Ξ±], MeasurableSingletonClass Ξ± := sorry | [['MeasurableSingletonClass'], ['EventuallyMeasurableSpace']] | instance measurableSingleton [MeasurableSingletonClass Ξ±] :
@MeasurableSingletonClass Ξ± (EventuallyMeasurableSpace m l) :=
@MeasurableSingletonClass.mk _ (_) <| fun x => (MeasurableSet.singleton x).eventuallyMeasurableSet | [['MeasurableSet', 'eventuallyMeasurableSet'], ['Set', 'instSingletonSet'], ['EventuallyMeasurableSpace'], ['Set'], ['Singleton', 'singleton'], ['MeasurableSet', 'singleton'], ['MeasurableSingletonClass', 'mk']] | theorem | Syntax(original=True, range=StringRange(start=3204, stop=3433)) | True | ['Mathlib', 'MeasureTheory', 'Constructions', 'EventuallyMeasurable'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
EventuallyMeasurable | import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
open Filter Set MeasurableSpace
open Function
| import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
| open Filter Set MeasurableSpace
open Function
| /-- We say a function is `EventuallyMeasurable` with respect to a given
Ο-algebra `m` and Ο-filter `l` if the preimage of any measurable set is equal to some
`m`-measurable set modulo `l`.
Warning: This is not always the same as being equal to some `m`-measurable function modulo `l`.
In general it is weaker. See `Measurable.eventuallyMeasurable_of_eventuallyEq`.
*TODO*: Add lemmas about when these are equivalent. -/
def EventuallyMeasurable (f : Ξ± β Ξ²) : Prop := sorry | def EventuallyMeasurable_extracted : {Ξ± : Type u_1} β
MeasurableSpace Ξ± β
(l : Filter Ξ±) β [inst : CountableInterFilter l] β {Ξ² : Type u_2} β [inst : MeasurableSpace Ξ²] β (Ξ± β Ξ²) β Prop := sorry | /-- We say a function is `EventuallyMeasurable` with respect to a given
Ο-algebra `m` and Ο-filter `l` if the preimage of any measurable set is equal to some
`m`-measurable set modulo `l`.
Warning: This is not always the same as being equal to some `m`-measurable function modulo `l`.
In general it is weaker. See `Measurable.eventuallyMeasurable_of_eventuallyEq`.
*TODO*: Add lemmas about when these are equivalent. -/
def EventuallyMeasurable (f : Ξ± β Ξ²) : Prop := @Measurable _ _ (EventuallyMeasurableSpace m l) _ f | [['EventuallyMeasurableSpace'], ['Measurable']] | We say a function is `EventuallyMeasurable` with respect to a given
Ο-algebra `m` and Ο-filter `l` if the preimage of any measurable set is equal to some
`m`-measurable set modulo `l`.
Warning: This is not always the same as being equal to some `m`-measurable function modulo `l`.
In general it is weaker. See `Measurable.eventuallyMeasurable_of_eventuallyEq`.
*TODO*: Add lemmas about when these are equivalent. | theorem | Syntax(original=True, range=StringRange(start=3600, stop=4124)) | True | ['Mathlib', 'MeasureTheory', 'Constructions', 'EventuallyMeasurable'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
Measurable.eventuallyMeasurable | import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
open Filter Set MeasurableSpace
open Function
| import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
| open Filter Set MeasurableSpace
open Function
| theorem Measurable.eventuallyMeasurable (hf : Measurable f) : EventuallyMeasurable m l f := sorry | theorem eventuallyMeasurable_extracted : β {Ξ± : Type u_1} {m : MeasurableSpace Ξ±} {l : Filter Ξ±} [inst : CountableInterFilter l] {Ξ² : Type u_2}
[inst_1 : MeasurableSpace Ξ²] {f : Ξ± β Ξ²}, Measurable f β EventuallyMeasurable m l f := sorry | [['EventuallyMeasurable']] | theorem Measurable.eventuallyMeasurable (hf : Measurable f) : EventuallyMeasurable m l f :=
hf.le EventuallyMeasurableSpace.measurable_le | [['EventuallyMeasurableSpace', 'measurable_le'], ['EventuallyMeasurableSpace'], ['Measurable', 'le']] | theorem | Syntax(original=True, range=StringRange(start=4176, stop=4315)) | True | ['Mathlib', 'MeasureTheory', 'Constructions', 'EventuallyMeasurable'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
Measurable.comp_eventuallyMeasurable | import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
open Filter Set MeasurableSpace
open Function
| import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
| open Filter Set MeasurableSpace
open Function
| theorem Measurable.comp_eventuallyMeasurable (hh : Measurable h) (hf : EventuallyMeasurable m l f) :
EventuallyMeasurable m l (h β f) := sorry | theorem comp_eventuallyMeasurable_extracted : β {Ξ± : Type u_1} {m : MeasurableSpace Ξ±} {l : Filter Ξ±} [inst : CountableInterFilter l] {Ξ² : Type u_2} {Ξ³ : Type u_3}
[inst_1 : MeasurableSpace Ξ²] [inst_2 : MeasurableSpace Ξ³] {f : Ξ± β Ξ²} {h : Ξ² β Ξ³},
Measurable h β EventuallyMeasurable m l f β EventuallyMeasurable m l (h β f) := sorry | [['Function', 'comp'], ['EventuallyMeasurable']] | theorem Measurable.comp_eventuallyMeasurable (hh : Measurable h) (hf : EventuallyMeasurable m l f) :
EventuallyMeasurable m l (h β f) :=
hh.comp hf | [['EventuallyMeasurableSpace'], ['Measurable', 'comp']] | theorem | Syntax(original=True, range=StringRange(start=4317, stop=4472)) | True | ['Mathlib', 'MeasureTheory', 'Constructions', 'EventuallyMeasurable'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
EventuallyMeasurable.congr | import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
open Filter Set MeasurableSpace
open Function
| import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
| open Filter Set MeasurableSpace
open Function
| /-- A function which is `EventuallyEq` to some `EventuallyMeasurable` function
is `EventuallyMeasurable`.-/
theorem EventuallyMeasurable.congr
(hf : EventuallyMeasurable m l f) (hgf : g =αΆ [l] f) : EventuallyMeasurable m l g := sorry | theorem congr_extracted : β {Ξ± : Type u_1} {m : MeasurableSpace Ξ±} {l : Filter Ξ±} [inst : CountableInterFilter l] {Ξ² : Type u_2}
[inst_1 : MeasurableSpace Ξ²] {f g : Ξ± β Ξ²}, EventuallyMeasurable m l f β g =αΆ [l] f β EventuallyMeasurable m l g := sorry | [['EventuallyMeasurable']] | /-- A function which is `EventuallyEq` to some `EventuallyMeasurable` function
is `EventuallyMeasurable`.-/
theorem EventuallyMeasurable.congr
(hf : EventuallyMeasurable m l f) (hgf : g =αΆ [l] f) : EventuallyMeasurable m l g :=
fun _ hs => EventuallyMeasurableSet.congr (hf hs)
(hgf.preimage _) | [['Set', 'preimage'], ['Filter', 'EventuallyEq', 'preimage'], ['EventuallyMeasurableSet', 'congr']] | A function which is `EventuallyEq` to some `EventuallyMeasurable` function
is `EventuallyMeasurable`. | theorem | Syntax(original=True, range=StringRange(start=4474, stop=4779)) | True | ['Mathlib', 'MeasureTheory', 'Constructions', 'EventuallyMeasurable'] | null | leanprover/lean4:v4.11.0
| Mathlib |
||||
Measurable.eventuallyMeasurable_of_eventuallyEq | import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
open Filter Set MeasurableSpace
open Function
| import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
| open Filter Set MeasurableSpace
open Function
| /-- A function which is `EventuallyEq` to some `Measurable` function is `EventuallyMeasurable`.-/
theorem Measurable.eventuallyMeasurable_of_eventuallyEq
(hf : Measurable f) (hgf : g =αΆ [l] f) : EventuallyMeasurable m l g := sorry | theorem eventuallyMeasurable_of_eventuallyEq_extracted : β {Ξ± : Type u_1} {m : MeasurableSpace Ξ±} {l : Filter Ξ±} [inst : CountableInterFilter l] {Ξ² : Type u_2}
[inst_1 : MeasurableSpace Ξ²] {f g : Ξ± β Ξ²}, Measurable f β g =αΆ [l] f β EventuallyMeasurable m l g := sorry | [['EventuallyMeasurable']] | /-- A function which is `EventuallyEq` to some `Measurable` function is `EventuallyMeasurable`.-/
theorem Measurable.eventuallyMeasurable_of_eventuallyEq
(hf : Measurable f) (hgf : g =αΆ [l] f) : EventuallyMeasurable m l g :=
hf.eventuallyMeasurable.congr hgf | [['EventuallyMeasurable', 'congr'], ['Measurable', 'eventuallyMeasurable']] | A function which is `EventuallyEq` to some `Measurable` function is `EventuallyMeasurable`. | theorem | Syntax(original=True, range=StringRange(start=4781, stop=5046)) | True | ['Mathlib', 'MeasureTheory', 'Constructions', 'EventuallyMeasurable'] | null | leanprover/lean4:v4.11.0
| Mathlib |
||||
EventuallyMeasurableSpace_tac_1889 | import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
open Filter Set MeasurableSpace
| import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
| open Filter Set MeasurableSpace
| lemma EventuallyMeasurableSpace_tac_1889 (m : MeasurableSpace Ξ±) (t : Set Ξ±) (l : Filter Ξ±) [CountableInterFilter l] (s : β β Set Ξ±) (hs : β (i : β), (fun s => β t, MeasurableSet t β§ s =αΆ [l] t) (s i)) : (fun s => β t, MeasurableSet t β§ s =αΆ [l] t) (β i, s i) := sorry | lemma EventuallyMeasurableSpace_tac_1889 {Ξ± : Type*} (m : MeasurableSpace Ξ±) (sβ : Set Ξ±) (t : Set Ξ±) (l : Filter Ξ±) [CountableInterFilter l] (s : β β Set Ξ±) (hs : β (i : β), (fun s => β t, MeasurableSet t β§ s =αΆ [l] t) (s i)) : (fun s => β t, MeasurableSet t β§ s =αΆ [l] t) (β i, s i) := sorry | [['hs'], ['hts'], ['EventuallyEq', 'countable_iUnion'], ['t'], ['ht'], ['MeasurableSet', 'iUnion'], ['i']] | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'EventuallyMeasurable'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||||||
EventuallyMeasurableSpace_tac_1889 | import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
open Filter Set MeasurableSpace
| import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
| open Filter Set MeasurableSpace
| lemma EventuallyMeasurableSpace_tac_1889 (m : MeasurableSpace Ξ±) (t : Set Ξ±) (l : Filter Ξ±) [CountableInterFilter l] (s : β β Set Ξ±) (hs : β (i : β), (fun s => β t, MeasurableSet t β§ s =αΆ [l] t) (s i)) : (fun s => β t, MeasurableSet t β§ s =αΆ [l] t) (β i, s i) := sorry | lemma EventuallyMeasurableSpace_tac_1889 {Ξ± : Type*} (m : MeasurableSpace Ξ±) (sβ : Set Ξ±) (t : Set Ξ±) (l : Filter Ξ±) [CountableInterFilter l] (s : β β Set Ξ±) (hs : β (i : β), (fun s => β t, MeasurableSet t β§ s =αΆ [l] t) (s i)) : (fun s => β t, MeasurableSet t β§ s =αΆ [l] t) (β i, s i) := sorry | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'EventuallyMeasurable'] | null | leanprover/lean4:v4.11.0
| Mathlib |
||||||||||
EventuallyMeasurableSpace_tac_1896 | import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
open Filter Set MeasurableSpace
| import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
| open Filter Set MeasurableSpace
| lemma EventuallyMeasurableSpace_tac_1896 (m : MeasurableSpace Ξ±) (t : Set Ξ±) (l : Filter Ξ±) [CountableInterFilter l] (s : β β Set Ξ±) (hs : β (i : β), (fun s => β t, MeasurableSet t β§ s =αΆ [l] t) (s i)) : (fun s => β t, MeasurableSet t β§ s =αΆ [l] t) (β i, s i) := sorry | lemma EventuallyMeasurableSpace_tac_1896 {Ξ± : Type*} (m : MeasurableSpace Ξ±) (sβ : Set Ξ±) (t : Set Ξ±) (l : Filter Ξ±) [CountableInterFilter l] (s : β β Set Ξ±) (hs : β (i : β), (fun s => β t, MeasurableSet t β§ s =αΆ [l] t) (s i)) : (fun s => β t, MeasurableSet t β§ s =αΆ [l] t) (β i, s i) := sorry | [['hs'], ['hts'], ['EventuallyEq', 'countable_iUnion'], ['t'], ['ht'], ['MeasurableSet', 'iUnion'], ['i']] | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'EventuallyMeasurable'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||||||
EventuallyMeasurableSpace_tac_1896 | import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
open Filter Set MeasurableSpace
| import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
| open Filter Set MeasurableSpace
| lemma EventuallyMeasurableSpace_tac_1896 (m : MeasurableSpace Ξ±) (t : Set Ξ±) (l : Filter Ξ±) [CountableInterFilter l] (s : β β Set Ξ±) (hs : β (i : β), (fun s => β t, MeasurableSet t β§ s =αΆ [l] t) (s i)) : (fun s => β t, MeasurableSet t β§ s =αΆ [l] t) (β i, s i) := sorry | lemma EventuallyMeasurableSpace_tac_1896 {Ξ± : Type*} (m : MeasurableSpace Ξ±) (sβ : Set Ξ±) (t : Set Ξ±) (l : Filter Ξ±) [CountableInterFilter l] (s : β β Set Ξ±) (hs : β (i : β), (fun s => β t, MeasurableSet t β§ s =αΆ [l] t) (s i)) : (fun s => β t, MeasurableSet t β§ s =αΆ [l] t) (β i, s i) := sorry | [['hs'], ['hts'], ['EventuallyEq', 'countable_iUnion'], ['t'], ['ht'], ['MeasurableSet', 'iUnion'], ['i']] | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'EventuallyMeasurable'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||||||
EventuallyMeasurableSpace_tac_1896 | import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
open Filter Set MeasurableSpace
| import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
| open Filter Set MeasurableSpace
| lemma EventuallyMeasurableSpace_tac_1896 (m : MeasurableSpace Ξ±) (t : Set Ξ±) (l : Filter Ξ±) [CountableInterFilter l] (s : β β Set Ξ±) (hs : β (i : β), (fun s => β t, MeasurableSet t β§ s =αΆ [l] t) (s i)) : (fun s => β t, MeasurableSet t β§ s =αΆ [l] t) (β i, s i) := sorry | lemma EventuallyMeasurableSpace_tac_1896 {Ξ± : Type*} (m : MeasurableSpace Ξ±) (sβ : Set Ξ±) (t : Set Ξ±) (l : Filter Ξ±) [CountableInterFilter l] (s : β β Set Ξ±) (hs : β (i : β), (fun s => β t, MeasurableSet t β§ s =αΆ [l] t) (s i)) : (fun s => β t, MeasurableSet t β§ s =αΆ [l] t) (β i, s i) := sorry | [['hs'], ['hts'], ['t'], ['ht']] | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'EventuallyMeasurable'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||||||
EventuallyMeasurableSpace_tac_1925 | import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
open Filter Set MeasurableSpace
| import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
| open Filter Set MeasurableSpace
| lemma EventuallyMeasurableSpace_tac_1925 (m : MeasurableSpace Ξ±) (l : Filter Ξ±) [CountableInterFilter l] (s : β β Set Ξ±) (t : β β Set Ξ±) (ht : β (i : β), MeasurableSet (t i)) (hts : β (i : β), s i =αΆ [l] t i) : β t, MeasurableSet t β§ β i, s i =αΆ [l] t := sorry | lemma EventuallyMeasurableSpace_tac_1925 {Ξ± : Type*} (m : MeasurableSpace Ξ±) (sβ : Set Ξ±) (tβ : Set Ξ±) (l : Filter Ξ±) [CountableInterFilter l] (s : β β Set Ξ±) (t : β β Set Ξ±) (ht : β (i : β), MeasurableSet (t i)) (hts : β (i : β), s i =αΆ [l] t i) : β t, MeasurableSet t β§ β i, s i =αΆ [l] t := sorry | [['hts'], ['EventuallyEq', 'countable_iUnion'], ['t'], ['ht'], ['MeasurableSet', 'iUnion'], ['i']] | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'EventuallyMeasurable'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||||||
EventuallyMeasurableSet.congr_tac_3069 | import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
open Filter Set MeasurableSpace
| import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
| open Filter Set MeasurableSpace
| lemma congr_tac_3069 (m : MeasurableSpace Ξ±) (s : Set Ξ±) (t : Set Ξ±) (l : Filter Ξ±) [CountableInterFilter l] (ht : EventuallyMeasurableSet m l t) (hst : s =αΆ [l] t) : EventuallyMeasurableSet m l s := sorry | lemma congr_tac_3069 {Ξ± : Type*} (m : MeasurableSpace Ξ±) (s : Set Ξ±) (t : Set Ξ±) (l : Filter Ξ±) [CountableInterFilter l] (ht : EventuallyMeasurableSet m l t) (hst : s =αΆ [l] t) : EventuallyMeasurableSet m l s := sorry | [['hst', 'trans'], ["ht'"], ["t'"], ['ht'], ["htt'"]] | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'EventuallyMeasurable'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||||||
EventuallyMeasurableSet.congr_tac_3069 | import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
open Filter Set MeasurableSpace
| import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
| open Filter Set MeasurableSpace
| lemma congr_tac_3069 (m : MeasurableSpace Ξ±) (s : Set Ξ±) (t : Set Ξ±) (l : Filter Ξ±) [CountableInterFilter l] (ht : EventuallyMeasurableSet m l t) (hst : s =αΆ [l] t) : EventuallyMeasurableSet m l s := sorry | lemma congr_tac_3069 {Ξ± : Type*} (m : MeasurableSpace Ξ±) (s : Set Ξ±) (t : Set Ξ±) (l : Filter Ξ±) [CountableInterFilter l] (ht : EventuallyMeasurableSet m l t) (hst : s =αΆ [l] t) : EventuallyMeasurableSet m l s := sorry | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'EventuallyMeasurable'] | null | leanprover/lean4:v4.11.0
| Mathlib |
||||||||||
EventuallyMeasurableSet.congr_tac_3074 | import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
open Filter Set MeasurableSpace
| import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
| open Filter Set MeasurableSpace
| lemma congr_tac_3074 (m : MeasurableSpace Ξ±) (s : Set Ξ±) (t : Set Ξ±) (l : Filter Ξ±) [CountableInterFilter l] (ht : EventuallyMeasurableSet m l t) (hst : s =αΆ [l] t) : EventuallyMeasurableSet m l s := sorry | lemma congr_tac_3074 {Ξ± : Type*} (m : MeasurableSpace Ξ±) (s : Set Ξ±) (t : Set Ξ±) (l : Filter Ξ±) [CountableInterFilter l] (ht : EventuallyMeasurableSet m l t) (hst : s =αΆ [l] t) : EventuallyMeasurableSet m l s := sorry | [['hst', 'trans'], ["ht'"], ["t'"], ['ht'], ["htt'"]] | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'EventuallyMeasurable'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||||||
EventuallyMeasurableSet.congr_tac_3074 | import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
open Filter Set MeasurableSpace
| import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
| open Filter Set MeasurableSpace
| lemma congr_tac_3074 (m : MeasurableSpace Ξ±) (s : Set Ξ±) (t : Set Ξ±) (l : Filter Ξ±) [CountableInterFilter l] (ht : EventuallyMeasurableSet m l t) (hst : s =αΆ [l] t) : EventuallyMeasurableSet m l s := sorry | lemma congr_tac_3074 {Ξ± : Type*} (m : MeasurableSpace Ξ±) (s : Set Ξ±) (t : Set Ξ±) (l : Filter Ξ±) [CountableInterFilter l] (ht : EventuallyMeasurableSet m l t) (hst : s =αΆ [l] t) : EventuallyMeasurableSet m l s := sorry | [['hst', 'trans'], ["ht'"], ["t'"], ['ht'], ["htt'"]] | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'EventuallyMeasurable'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||||||
EventuallyMeasurableSet.congr_tac_3074 | import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
open Filter Set MeasurableSpace
| import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
| open Filter Set MeasurableSpace
| lemma congr_tac_3074 (m : MeasurableSpace Ξ±) (s : Set Ξ±) (t : Set Ξ±) (l : Filter Ξ±) [CountableInterFilter l] (ht : EventuallyMeasurableSet m l t) (hst : s =αΆ [l] t) : EventuallyMeasurableSet m l s := sorry | lemma congr_tac_3074 {Ξ± : Type*} (m : MeasurableSpace Ξ±) (s : Set Ξ±) (t : Set Ξ±) (l : Filter Ξ±) [CountableInterFilter l] (ht : EventuallyMeasurableSet m l t) (hst : s =αΆ [l] t) : EventuallyMeasurableSet m l s := sorry | [["ht'"], ["t'"], ['ht'], ["htt'"]] | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'EventuallyMeasurable'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||||||
EventuallyMeasurableSet.congr_tac_3111 | import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
open Filter Set MeasurableSpace
| import Init
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.Order.Filter.CountableInter
import Mathlib.MeasureTheory.Constructions.EventuallyMeasurable
| open Filter Set MeasurableSpace
| lemma congr_tac_3111 (m : MeasurableSpace Ξ±) (s : Set Ξ±) (t : Set Ξ±) (l : Filter Ξ±) [CountableInterFilter l] (hst : s =αΆ [l] t) (t' : Set Ξ±) (ht' : MeasurableSet t') (htt' : t =αΆ [l] t') : EventuallyMeasurableSet m l s := sorry | lemma congr_tac_3111 {Ξ± : Type*} (m : MeasurableSpace Ξ±) (s : Set Ξ±) (t : Set Ξ±) (l : Filter Ξ±) [CountableInterFilter l] (hst : s =αΆ [l] t) (t' : Set Ξ±) (ht' : MeasurableSet t') (htt' : t =αΆ [l] t') : EventuallyMeasurableSet m l s := sorry | [['hst', 'trans'], ["ht'"], ["t'"], ["htt'"]] | tactic | ['Mathlib', 'MeasureTheory', 'Constructions', 'EventuallyMeasurable'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||||||
ContinuousLinearMap.measurable | import Init
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.Analysis.NormedSpace.OperatorNorm.NormedSpace
import Mathlib.Topology.Algebra.Module.FiniteDimension
import Mathlib.MeasureTheory.Constructions.BorelSpace.ContinuousLinearMap
open MeasureTheory
| import Init
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.Analysis.NormedSpace.OperatorNorm.NormedSpace
import Mathlib.Topology.Algebra.Module.FiniteDimension
import Mathlib.MeasureTheory.Constructions.BorelSpace.ContinuousLinearMap
| open MeasureTheory
| @[fun_prop, measurability]
protected theorem measurable (L : E βL[π] F) : Measurable L := sorry | theorem measurable_extracted : β {π : Type u_2} [inst : NormedField π] {E : Type u_3} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace π E]
[inst_3 : MeasurableSpace E] [inst_4 : OpensMeasurableSpace E] {F : Type u_4} [inst_5 : NormedAddCommGroup F]
[inst_6 : NormedSpace π F] [inst_7 : MeasurableSpace F] [inst_8 : BorelSpace F] (L : E βL[π] F), Measurable βL := sorry | [['NormedAddCommGroup', 'toAddCommGroup'], ['SeminormedAddCommGroup', 'toPseudoMetricSpace'], ['PseudoMetricSpace', 'toUniformSpace'], ['Field', 'toSemifield'], ['AddCommGroup', 'toAddCommMonoid'], ['RingHom', 'id'], ['NormedField', 'toField'], ['DivisionSemiring', 'toSemiring'], ['Semiring', 'toNonAssocSemiring'], ['ContinuousLinearMap'], ['ContinuousLinearMap', 'funLike'], ['NormedAddCommGroup', 'toSeminormedAddCommGroup'], ['Measurable'], ['Semifield', 'toDivisionSemiring'], ['DFunLike', 'coe'], ['UniformSpace', 'toTopologicalSpace'], ['NormedSpace', 'toModule']] | @[fun_prop, measurability]
protected theorem measurable (L : E βL[π] F) : Measurable L :=
L.continuous.measurable | [['NormedAddCommGroup', 'toAddCommGroup'], ['ContinuousLinearMap', 'continuous'], ['SeminormedAddCommGroup', 'toPseudoMetricSpace'], ['PseudoMetricSpace', 'toUniformSpace'], ['Field', 'toSemifield'], ['AddCommGroup', 'toAddCommMonoid'], ['RingHom', 'id'], ['NormedField', 'toField'], ['DivisionSemiring', 'toSemiring'], ['Continuous', 'measurable'], ['Semiring', 'toNonAssocSemiring'], ['ContinuousLinearMap'], ['ContinuousLinearMap', 'funLike'], ['NormedAddCommGroup', 'toSeminormedAddCommGroup'], ['Semifield', 'toDivisionSemiring'], ['UniformSpace', 'toTopologicalSpace'], ['DFunLike', 'coe'], ['NormedSpace', 'toModule']] | theorem | Syntax(original=True, range=StringRange(start=725, stop=845)) | True | ['Mathlib', 'MeasureTheory', 'Constructions', 'BorelSpace', 'ContinuousLinearMap'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
ContinuousLinearMap.measurable_comp | import Init
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.Analysis.NormedSpace.OperatorNorm.NormedSpace
import Mathlib.Topology.Algebra.Module.FiniteDimension
import Mathlib.MeasureTheory.Constructions.BorelSpace.ContinuousLinearMap
open MeasureTheory
| import Init
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.Analysis.NormedSpace.OperatorNorm.NormedSpace
import Mathlib.Topology.Algebra.Module.FiniteDimension
import Mathlib.MeasureTheory.Constructions.BorelSpace.ContinuousLinearMap
| open MeasureTheory
| @[fun_prop]
theorem measurable_comp (L : E βL[π] F) {Ο : Ξ± β E} (Ο_meas : Measurable Ο) :
Measurable fun a : Ξ± => L (Ο a) := sorry | theorem measurable_comp_extracted : β {Ξ± : Type u_1} [inst : MeasurableSpace Ξ±] {π : Type u_2} [inst_1 : NormedField π] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace π E] [inst_4 : MeasurableSpace E]
[inst_5 : OpensMeasurableSpace E] {F : Type u_4} [inst_6 : NormedAddCommGroup F] [inst_7 : NormedSpace π F]
[inst_8 : MeasurableSpace F] [inst_9 : BorelSpace F] (L : E βL[π] F) {Ο : Ξ± β E},
Measurable Ο β Measurable fun a => L (Ο a) := sorry | [['NormedAddCommGroup', 'toAddCommGroup'], ['SeminormedAddCommGroup', 'toPseudoMetricSpace'], ['PseudoMetricSpace', 'toUniformSpace'], ['Field', 'toSemifield'], ['AddCommGroup', 'toAddCommMonoid'], ['RingHom', 'id'], ['NormedField', 'toField'], ['DivisionSemiring', 'toSemiring'], ['Semiring', 'toNonAssocSemiring'], ['ContinuousLinearMap'], ['ContinuousLinearMap', 'funLike'], ['NormedAddCommGroup', 'toSeminormedAddCommGroup'], ['Measurable'], ['Semifield', 'toDivisionSemiring'], ['DFunLike', 'coe'], ['UniformSpace', 'toTopologicalSpace'], ['NormedSpace', 'toModule']] | @[fun_prop]
theorem measurable_comp (L : E βL[π] F) {Ο : Ξ± β E} (Ο_meas : Measurable Ο) :
Measurable fun a : Ξ± => L (Ο a) :=
L.measurable.comp Ο_meas | [['NormedAddCommGroup', 'toAddCommGroup'], ['SeminormedAddCommGroup', 'toPseudoMetricSpace'], ['PseudoMetricSpace', 'toUniformSpace'], ['Field', 'toSemifield'], ['AddCommGroup', 'toAddCommMonoid'], ['RingHom', 'id'], ['Measurable', 'comp'], ['NormedField', 'toField'], ['DivisionSemiring', 'toSemiring'], ['Semiring', 'toNonAssocSemiring'], ['ContinuousLinearMap'], ['ContinuousLinearMap', 'funLike'], ['NormedAddCommGroup', 'toSeminormedAddCommGroup'], ['Semifield', 'toDivisionSemiring'], ['ContinuousLinearMap', 'measurable'], ['DFunLike', 'coe'], ['UniformSpace', 'toTopologicalSpace'], ['NormedSpace', 'toModule']] | theorem | Syntax(original=True, range=StringRange(start=847, stop=1016)) | True | ['Mathlib', 'MeasureTheory', 'Constructions', 'BorelSpace', 'ContinuousLinearMap'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
ContinuousLinearMap.instMeasurableSpace | import Init
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.Analysis.NormedSpace.OperatorNorm.NormedSpace
import Mathlib.Topology.Algebra.Module.FiniteDimension
import Mathlib.MeasureTheory.Constructions.BorelSpace.ContinuousLinearMap
open MeasureTheory
| import Init
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.Analysis.NormedSpace.OperatorNorm.NormedSpace
import Mathlib.Topology.Algebra.Module.FiniteDimension
import Mathlib.MeasureTheory.Constructions.BorelSpace.ContinuousLinearMap
| open MeasureTheory
| instance instMeasurableSpace : MeasurableSpace (E βL[π] F) := sorry | def instMeasurableSpace_extracted : {π : Type u_2} β
[inst : NontriviallyNormedField π] β
{E : Type u_3} β
[inst_1 : NormedAddCommGroup E] β
[inst_2 : NormedSpace π E] β
{F : Type u_4} β [inst_3 : NormedAddCommGroup F] β [inst_4 : NormedSpace π F] β MeasurableSpace (E βL[π] F) := sorry | [['NormedAddCommGroup', 'toAddCommGroup'], ['NormedField', 'toField'], ['DivisionSemiring', 'toSemiring'], ['Semiring', 'toNonAssocSemiring'], ['ContinuousLinearMap'], ['SeminormedAddCommGroup', 'toPseudoMetricSpace'], ['NontriviallyNormedField', 'toNormedField'], ['NormedAddCommGroup', 'toSeminormedAddCommGroup'], ['PseudoMetricSpace', 'toUniformSpace'], ['AddCommGroup', 'toAddCommMonoid'], ['Field', 'toSemifield'], ['Semifield', 'toDivisionSemiring'], ['NormedSpace', 'toModule'], ['UniformSpace', 'toTopologicalSpace'], ['RingHom', 'id'], ['MeasurableSpace']] | instance instMeasurableSpace : MeasurableSpace (E βL[π] F) :=
borel _ | [['ContinuousLinearMap', 'instMeasurableSpace', 'proof_1'], ['NormedAddCommGroup', 'toAddCommGroup'], ['ContinuousLinearMap', 'topologicalSpace'], ['borel'], ['NontriviallyNormedField', 'toNormedField'], ['SeminormedAddCommGroup', 'toPseudoMetricSpace'], ['PseudoMetricSpace', 'toUniformSpace'], ['Field', 'toSemifield'], ['AddCommGroup', 'toAddCommMonoid'], ['RingHom', 'id'], ['NormedField', 'toField'], ['DivisionSemiring', 'toSemiring'], ['SeminormedAddCommGroup', 'toAddCommGroup'], ['Semiring', 'toNonAssocSemiring'], ['ContinuousLinearMap'], ['NormedAddCommGroup', 'toSeminormedAddCommGroup'], ['Semifield', 'toDivisionSemiring'], ['UniformSpace', 'toTopologicalSpace'], ['NormedSpace', 'toModule']] | theorem | Syntax(original=True, range=StringRange(start=1253, stop=1329)) | True | ['Mathlib', 'MeasureTheory', 'Constructions', 'BorelSpace', 'ContinuousLinearMap'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
ContinuousLinearMap.instBorelSpace | import Init
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.Analysis.NormedSpace.OperatorNorm.NormedSpace
import Mathlib.Topology.Algebra.Module.FiniteDimension
import Mathlib.MeasureTheory.Constructions.BorelSpace.ContinuousLinearMap
open MeasureTheory
| import Init
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.Analysis.NormedSpace.OperatorNorm.NormedSpace
import Mathlib.Topology.Algebra.Module.FiniteDimension
import Mathlib.MeasureTheory.Constructions.BorelSpace.ContinuousLinearMap
| open MeasureTheory
| instance instBorelSpace : BorelSpace (E βL[π] F) := sorry | def instBorelSpace_extracted : β {π : Type u_2} [inst : NontriviallyNormedField π] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace π E] {F : Type u_4} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace π F],
BorelSpace (E βL[π] F) := sorry | [['NormedAddCommGroup', 'toAddCommGroup'], ['ContinuousLinearMap', 'topologicalSpace'], ['SeminormedAddCommGroup', 'toTopologicalAddGroup'], ['BorelSpace'], ['NontriviallyNormedField', 'toNormedField'], ['SeminormedAddCommGroup', 'toPseudoMetricSpace'], ['PseudoMetricSpace', 'toUniformSpace'], ['Field', 'toSemifield'], ['AddCommGroup', 'toAddCommMonoid'], ['ContinuousLinearMap', 'instMeasurableSpace'], ['RingHom', 'id'], ['NormedField', 'toField'], ['DivisionSemiring', 'toSemiring'], ['SeminormedAddCommGroup', 'toAddCommGroup'], ['Semiring', 'toNonAssocSemiring'], ['ContinuousLinearMap'], ['NormedAddCommGroup', 'toSeminormedAddCommGroup'], ['Semifield', 'toDivisionSemiring'], ['UniformSpace', 'toTopologicalSpace'], ['NormedSpace', 'toModule']] | instance instBorelSpace : BorelSpace (E βL[π] F) :=
β¨rflβ© | [['NormedAddCommGroup', 'toAddCommGroup'], ['ContinuousLinearMap', 'topologicalSpace'], ['SeminormedAddCommGroup', 'toTopologicalAddGroup'], ['BorelSpace', 'mk'], ['NontriviallyNormedField', 'toNormedField'], ['SeminormedAddCommGroup', 'toPseudoMetricSpace'], ['PseudoMetricSpace', 'toUniformSpace'], ['Field', 'toSemifield'], ['AddCommGroup', 'toAddCommMonoid'], ['rfl'], ['ContinuousLinearMap', 'instMeasurableSpace'], ['RingHom', 'id'], ['NormedField', 'toField'], ['DivisionSemiring', 'toSemiring'], ['SeminormedAddCommGroup', 'toAddCommGroup'], ['Semiring', 'toNonAssocSemiring'], ['ContinuousLinearMap'], ['NormedAddCommGroup', 'toSeminormedAddCommGroup'], ['Semifield', 'toDivisionSemiring'], ['UniformSpace', 'toTopologicalSpace'], ['NormedSpace', 'toModule'], ['MeasurableSpace']] | theorem | Syntax(original=True, range=StringRange(start=1331, stop=1399)) | True | ['Mathlib', 'MeasureTheory', 'Constructions', 'BorelSpace', 'ContinuousLinearMap'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
ContinuousLinearMap.measurable_apply | import Init
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.Analysis.NormedSpace.OperatorNorm.NormedSpace
import Mathlib.Topology.Algebra.Module.FiniteDimension
import Mathlib.MeasureTheory.Constructions.BorelSpace.ContinuousLinearMap
open MeasureTheory
| import Init
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.Analysis.NormedSpace.OperatorNorm.NormedSpace
import Mathlib.Topology.Algebra.Module.FiniteDimension
import Mathlib.MeasureTheory.Constructions.BorelSpace.ContinuousLinearMap
| open MeasureTheory
| @[fun_prop, measurability]
theorem measurable_apply [MeasurableSpace F] [BorelSpace F] (x : E) :
Measurable fun f : E βL[π] F => f x := sorry | theorem measurable_apply_extracted : β {π : Type u_2} [inst : NontriviallyNormedField π] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace π E] {F : Type u_4} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace π F]
[inst_5 : MeasurableSpace F] [inst_6 : BorelSpace F] (x : E), Measurable fun f => f x := sorry | [['NormedAddCommGroup', 'toAddCommGroup'], ['NontriviallyNormedField', 'toNormedField'], ['SeminormedAddCommGroup', 'toPseudoMetricSpace'], ['PseudoMetricSpace', 'toUniformSpace'], ['Field', 'toSemifield'], ['AddCommGroup', 'toAddCommMonoid'], ['RingHom', 'id'], ['ContinuousLinearMap', 'instMeasurableSpace'], ['NormedField', 'toField'], ['DivisionSemiring', 'toSemiring'], ['Semiring', 'toNonAssocSemiring'], ['ContinuousLinearMap'], ['ContinuousLinearMap', 'funLike'], ['NormedAddCommGroup', 'toSeminormedAddCommGroup'], ['Measurable'], ['Semifield', 'toDivisionSemiring'], ['DFunLike', 'coe'], ['UniformSpace', 'toTopologicalSpace'], ['NormedSpace', 'toModule']] | @[fun_prop, measurability]
theorem measurable_apply [MeasurableSpace F] [BorelSpace F] (x : E) :
Measurable fun f : E βL[π] F => f x :=
(apply π F x).continuous.measurable | [['CommMonoidWithZero', 'toZero'], ['AddCommGroup', 'toDivisionAddCommMonoid'], ['SeminormedAddCommGroup', 'toTopologicalAddGroup'], ['ContinuousLinearMap', 'continuous'], ['ContinuousLinearMap', 'apply'], ['NontriviallyNormedField', 'toNormedField'], ['Semiring', 'toMonoidWithZero'], ['SeminormedRing', 'toPseudoMetricSpace'], ['AddCommGroup', 'toAddCommMonoid'], ['AddCommMonoid', 'toAddMonoid'], ['Semifield', 'toCommGroupWithZero'], ['SubtractionCommMonoid', 'toSubtractionMonoid'], ['SeminormedAddGroup', 'toAddGroup'], ['RingHom', 'id'], ['BorelSpace', 'opensMeasurable'], ['ContinuousLinearMap', 'module'], ['ContinuousLinearMap', 'addCommGroup'], ['NormedField', 'toField'], ['Field', 'toCommRing'], ['SMulWithZero', 'toSMulZeroClass'], ['SeminormedCommRing', 'toSeminormedRing'], ['SeminormedAddCommGroup', 'toAddCommGroup'], ['Semiring', 'toNonAssocSemiring'], ['Continuous', 'measurable'], ['ContinuousLinearMap', 'funLike'], ['NormedSpace', 'boundedSMul'], ['AddMonoid', 'toZero'], ['UniformSpace', 'toTopologicalSpace'], ['DFunLike', 'coe'], ['NormedRing', 'toRing'], ['SubtractionMonoid', 'toSubNegZeroMonoid'], ['MulActionWithZero', 'toMulAction'], ['TopologicalAddGroup', 'toContinuousAdd'], ['ContinuousLinearMap', 'topologicalSpace'], ['ContinuousLinearMap', 'instBorelSpace'], ['SeminormedAddCommGroup', 'toPseudoMetricSpace'], ['smulCommClass_self'], ['PseudoMetricSpace', 'toUniformSpace'], ['NormedCommRing', 'toNormedRing'], ['ContinuousSMul', 'continuousConstSMul'], ['Field', 'toSemifield'], ['NormedField', 'toNormedCommRing'], ['Module', 'toMulActionWithZero'], ['SubNegZeroMonoid', 'toNegZeroClass'], ['CommGroupWithZero', 'toCommMonoidWithZero'], ['ContinuousLinearMap', 'instMeasurableSpace'], ['SMulZeroClass', 'toSMul'], ['NormedCommRing', 'toSeminormedCommRing'], ['DivisionSemiring', 'toSemiring'], ['CommRing', 'toCommMonoid'], ['MulActionWithZero', 'toSMulWithZero'], ['ContinuousLinearMap'], ['NormedAddCommGroup', 'toSeminormedAddCommGroup'], ['Semifield', 'toDivisionSemiring'], ['ContinuousLinearMap', 'addCommMonoid'], ['MonoidWithZero', 'toZero'], ['NormedSpace', 'toModule'], ['BoundedSMul', 'continuousSMul'], ['SeminormedAddCommGroup', 'toSeminormedAddGroup'], ['NegZeroClass', 'toZero']] | theorem | Syntax(original=True, range=StringRange(start=1401, stop=1586)) | True | ['Mathlib', 'MeasureTheory', 'Constructions', 'BorelSpace', 'ContinuousLinearMap'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
ContinuousLinearMap.measurable_apply' | import Init
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.Analysis.NormedSpace.OperatorNorm.NormedSpace
import Mathlib.Topology.Algebra.Module.FiniteDimension
import Mathlib.MeasureTheory.Constructions.BorelSpace.ContinuousLinearMap
open MeasureTheory
| import Init
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.Analysis.NormedSpace.OperatorNorm.NormedSpace
import Mathlib.Topology.Algebra.Module.FiniteDimension
import Mathlib.MeasureTheory.Constructions.BorelSpace.ContinuousLinearMap
| open MeasureTheory
| @[measurability]
theorem measurable_apply' [MeasurableSpace E] [OpensMeasurableSpace E] [MeasurableSpace F]
[BorelSpace F] : Measurable fun (x : E) (f : E βL[π] F) => f x := sorry | theorem measurable_apply'_extracted : β {π : Type u_2} [inst : NontriviallyNormedField π] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace π E] {F : Type u_4} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace π F]
[inst_5 : MeasurableSpace E] [inst_6 : OpensMeasurableSpace E] [inst_7 : MeasurableSpace F] [inst_8 : BorelSpace F],
Measurable fun x f => f x := sorry | [['NormedAddCommGroup', 'toAddCommGroup'], ['NontriviallyNormedField', 'toNormedField'], ['SeminormedAddCommGroup', 'toPseudoMetricSpace'], ['PseudoMetricSpace', 'toUniformSpace'], ['Field', 'toSemifield'], ['AddCommGroup', 'toAddCommMonoid'], ['RingHom', 'id'], ['NormedField', 'toField'], ['DivisionSemiring', 'toSemiring'], ['Semiring', 'toNonAssocSemiring'], ['ContinuousLinearMap'], ['MeasurableSpace', 'pi'], ['ContinuousLinearMap', 'funLike'], ['NormedAddCommGroup', 'toSeminormedAddCommGroup'], ['Measurable'], ['Semifield', 'toDivisionSemiring'], ['DFunLike', 'coe'], ['UniformSpace', 'toTopologicalSpace'], ['NormedSpace', 'toModule']] | @[measurability]
theorem measurable_apply' [MeasurableSpace E] [OpensMeasurableSpace E] [MeasurableSpace F]
[BorelSpace F] : Measurable fun (x : E) (f : E βL[π] F) => f x :=
measurable_pi_lambda _ fun f => f.measurable | [['NormedAddCommGroup', 'toAddCommGroup'], ['NontriviallyNormedField', 'toNormedField'], ['SeminormedAddCommGroup', 'toPseudoMetricSpace'], ['PseudoMetricSpace', 'toUniformSpace'], ['Field', 'toSemifield'], ['AddCommGroup', 'toAddCommMonoid'], ['measurable_pi_lambda'], ['RingHom', 'id'], ['NormedField', 'toField'], ['DivisionSemiring', 'toSemiring'], ['Semiring', 'toNonAssocSemiring'], ['ContinuousLinearMap'], ['ContinuousLinearMap', 'funLike'], ['NormedAddCommGroup', 'toSeminormedAddCommGroup'], ['Semifield', 'toDivisionSemiring'], ['ContinuousLinearMap', 'measurable'], ['UniformSpace', 'toTopologicalSpace'], ['NormedSpace', 'toModule'], ['DFunLike', 'coe']] | theorem | Syntax(original=True, range=StringRange(start=1588, stop=1817)) | True | ['Mathlib', 'MeasureTheory', 'Constructions', 'BorelSpace', 'ContinuousLinearMap'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
ContinuousLinearMap.measurable_coe | import Init
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.Analysis.NormedSpace.OperatorNorm.NormedSpace
import Mathlib.Topology.Algebra.Module.FiniteDimension
import Mathlib.MeasureTheory.Constructions.BorelSpace.ContinuousLinearMap
open MeasureTheory
| import Init
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.Analysis.NormedSpace.OperatorNorm.NormedSpace
import Mathlib.Topology.Algebra.Module.FiniteDimension
import Mathlib.MeasureTheory.Constructions.BorelSpace.ContinuousLinearMap
| open MeasureTheory
| @[measurability]
theorem measurable_coe [MeasurableSpace F] [BorelSpace F] :
Measurable fun (f : E βL[π] F) (x : E) => f x := sorry | theorem measurable_coe_extracted : β {π : Type u_2} [inst : NontriviallyNormedField π] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace π E] {F : Type u_4} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace π F]
[inst_5 : MeasurableSpace F] [inst_6 : BorelSpace F], Measurable fun f x => f x := sorry | [['NormedAddCommGroup', 'toAddCommGroup'], ['NontriviallyNormedField', 'toNormedField'], ['SeminormedAddCommGroup', 'toPseudoMetricSpace'], ['PseudoMetricSpace', 'toUniformSpace'], ['Field', 'toSemifield'], ['AddCommGroup', 'toAddCommMonoid'], ['RingHom', 'id'], ['ContinuousLinearMap', 'instMeasurableSpace'], ['NormedField', 'toField'], ['DivisionSemiring', 'toSemiring'], ['Semiring', 'toNonAssocSemiring'], ['ContinuousLinearMap'], ['MeasurableSpace', 'pi'], ['ContinuousLinearMap', 'funLike'], ['NormedAddCommGroup', 'toSeminormedAddCommGroup'], ['Measurable'], ['Semifield', 'toDivisionSemiring'], ['DFunLike', 'coe'], ['UniformSpace', 'toTopologicalSpace'], ['NormedSpace', 'toModule']] | @[measurability]
theorem measurable_coe [MeasurableSpace F] [BorelSpace F] :
Measurable fun (f : E βL[π] F) (x : E) => f x :=
measurable_pi_lambda _ measurable_apply | [['NormedAddCommGroup', 'toAddCommGroup'], ['NontriviallyNormedField', 'toNormedField'], ['SeminormedAddCommGroup', 'toPseudoMetricSpace'], ['PseudoMetricSpace', 'toUniformSpace'], ['Field', 'toSemifield'], ['AddCommGroup', 'toAddCommMonoid'], ['ContinuousLinearMap', 'measurable_apply'], ['measurable_pi_lambda'], ['RingHom', 'id'], ['ContinuousLinearMap', 'instMeasurableSpace'], ['NormedField', 'toField'], ['DivisionSemiring', 'toSemiring'], ['Semiring', 'toNonAssocSemiring'], ['ContinuousLinearMap'], ['ContinuousLinearMap', 'funLike'], ['NormedAddCommGroup', 'toSeminormedAddCommGroup'], ['Semifield', 'toDivisionSemiring'], ['DFunLike', 'coe'], ['UniformSpace', 'toTopologicalSpace'], ['NormedSpace', 'toModule']] | theorem | Syntax(original=True, range=StringRange(start=1819, stop=1995)) | True | ['Mathlib', 'MeasureTheory', 'Constructions', 'BorelSpace', 'ContinuousLinearMap'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
Measurable.apply_continuousLinearMap | import Init
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.Analysis.NormedSpace.OperatorNorm.NormedSpace
import Mathlib.Topology.Algebra.Module.FiniteDimension
import Mathlib.MeasureTheory.Constructions.BorelSpace.ContinuousLinearMap
open MeasureTheory
| import Init
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.Analysis.NormedSpace.OperatorNorm.NormedSpace
import Mathlib.Topology.Algebra.Module.FiniteDimension
import Mathlib.MeasureTheory.Constructions.BorelSpace.ContinuousLinearMap
| open MeasureTheory
| @[fun_prop, measurability]
theorem Measurable.apply_continuousLinearMap {Ο : Ξ± β F βL[π] E} (hΟ : Measurable Ο) (v : F) :
Measurable fun a => Ο a v := sorry | theorem apply_continuousLinearMap_extracted : β {Ξ± : Type u_1} [inst : MeasurableSpace Ξ±] {π : Type u_2} [inst_1 : NontriviallyNormedField π] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace π E] [inst_4 : MeasurableSpace E] [inst_5 : BorelSpace E]
{F : Type u_4} [inst_6 : NormedAddCommGroup F] [inst_7 : NormedSpace π F] {Ο : Ξ± β F βL[π] E},
Measurable Ο β β (v : F), Measurable fun a => (Ο a) v := sorry | [['NormedAddCommGroup', 'toAddCommGroup'], ['NontriviallyNormedField', 'toNormedField'], ['SeminormedAddCommGroup', 'toPseudoMetricSpace'], ['PseudoMetricSpace', 'toUniformSpace'], ['Field', 'toSemifield'], ['AddCommGroup', 'toAddCommMonoid'], ['RingHom', 'id'], ['NormedField', 'toField'], ['DivisionSemiring', 'toSemiring'], ['Semiring', 'toNonAssocSemiring'], ['ContinuousLinearMap'], ['ContinuousLinearMap', 'funLike'], ['NormedAddCommGroup', 'toSeminormedAddCommGroup'], ['Measurable'], ['Semifield', 'toDivisionSemiring'], ['DFunLike', 'coe'], ['UniformSpace', 'toTopologicalSpace'], ['NormedSpace', 'toModule']] | @[fun_prop, measurability]
theorem Measurable.apply_continuousLinearMap {Ο : Ξ± β F βL[π] E} (hΟ : Measurable Ο) (v : F) :
Measurable fun a => Ο a v :=
(ContinuousLinearMap.apply π E v).measurable.comp hΟ | [['ContinuousLinearMap', 'apply'], ['NontriviallyNormedField', 'toNormedField'], ['AddCommGroup', 'toAddCommMonoid'], ['ContinuousLinearMap', 'toNormedAddCommGroup'], ['Semifield', 'toCommGroupWithZero'], ['SeminormedCommRing', 'toSeminormedRing'], ['Semiring', 'toNonAssocSemiring'], ['SMulWithZero', 'toSMulZeroClass'], ['MulActionWithZero', 'toMulAction'], ['NormedRing', 'toRing'], ['TopologicalAddGroup', 'toContinuousAdd'], ['ContinuousLinearMap', 'topologicalSpace'], ['ContinuousLinearMap', 'instBorelSpace'], ['smulCommClass_self'], ['PseudoMetricSpace', 'toUniformSpace'], ['NormedCommRing', 'toNormedRing'], ['Module', 'toMulActionWithZero'], ['EuclideanDomain', 'toCommRing'], ['CommGroupWithZero', 'toCommMonoidWithZero'], ['SMulZeroClass', 'toSMul'], ['CommRing', 'toCommMonoid'], ['MulActionWithZero', 'toSMulWithZero'], ['ContinuousLinearMap'], ['Field', 'toEuclideanDomain'], ['NormedAddCommGroup', 'toSeminormedAddCommGroup'], ['NormedSpace', 'toModule'], ['MonoidWithZero', 'toZero'], ['SeminormedAddCommGroup', 'toSeminormedAddGroup'], ['BoundedSMul', 'continuousSMul'], ['NormedAddCommGroup', 'toAddCommGroup'], ['AddCommGroup', 'toDivisionAddCommMonoid'], ['SeminormedAddCommGroup', 'toTopologicalAddGroup'], ['CommMonoidWithZero', 'toZero'], ['Semiring', 'toMonoidWithZero'], ['ContinuousLinearMap', 'toNormedSpace'], ['SeminormedRing', 'toPseudoMetricSpace'], ['AddCommMonoid', 'toAddMonoid'], ['SubtractionCommMonoid', 'toSubtractionMonoid'], ['SeminormedAddGroup', 'toAddGroup'], ['RingHom', 'id'], ['ContinuousLinearMap', 'module'], ['BorelSpace', 'opensMeasurable'], ['NormedField', 'toField'], ['Field', 'toCommRing'], ['ContinuousLinearMap', 'addCommGroup'], ['SeminormedAddCommGroup', 'toAddCommGroup'], ['ContinuousLinearMap', 'funLike'], ['AddMonoid', 'toZero'], ['NormedSpace', 'boundedSMul'], ['DFunLike', 'coe'], ['UniformSpace', 'toTopologicalSpace'], ['ContinuousLinearMap', 'measurable'], ['SubtractionMonoid', 'toSubNegZeroMonoid'], ['SeminormedAddCommGroup', 'toPseudoMetricSpace'], ['Field', 'toSemifield'], ['ContinuousSMul', 'continuousConstSMul'], ['SubNegZeroMonoid', 'toNegZeroClass'], ['NormedField', 'toNormedCommRing'], ['ContinuousLinearMap', 'instMeasurableSpace'], ['Measurable', 'comp'], ['NormedCommRing', 'toSeminormedCommRing'], ['DivisionSemiring', 'toSemiring'], ['RingHomIsometric', 'ids'], ['Semifield', 'toDivisionSemiring'], ['ContinuousLinearMap', 'addCommMonoid'], ['NegZeroClass', 'toZero']] | theorem | Syntax(original=True, range=StringRange(start=2288, stop=2513)) | True | ['Mathlib', 'MeasureTheory', 'Constructions', 'BorelSpace', 'ContinuousLinearMap'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
AEMeasurable.apply_continuousLinearMap | import Init
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.Analysis.NormedSpace.OperatorNorm.NormedSpace
import Mathlib.Topology.Algebra.Module.FiniteDimension
import Mathlib.MeasureTheory.Constructions.BorelSpace.ContinuousLinearMap
open MeasureTheory
| import Init
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.Analysis.NormedSpace.OperatorNorm.NormedSpace
import Mathlib.Topology.Algebra.Module.FiniteDimension
import Mathlib.MeasureTheory.Constructions.BorelSpace.ContinuousLinearMap
| open MeasureTheory
| @[measurability]
theorem AEMeasurable.apply_continuousLinearMap {Ο : Ξ± β F βL[π] E} {ΞΌ : Measure Ξ±}
(hΟ : AEMeasurable Ο ΞΌ) (v : F) : AEMeasurable (fun a => Ο a v) ΞΌ := sorry | theorem apply_continuousLinearMap_extracted : β {Ξ± : Type u_1} [inst : MeasurableSpace Ξ±] {π : Type u_2} [inst_1 : NontriviallyNormedField π] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace π E] [inst_4 : MeasurableSpace E] [inst_5 : BorelSpace E]
{F : Type u_4} [inst_6 : NormedAddCommGroup F] [inst_7 : NormedSpace π F] {Ο : Ξ± β F βL[π] E} {ΞΌ : Measure Ξ±},
AEMeasurable Ο ΞΌ β β (v : F), AEMeasurable (fun a => (Ο a) v) ΞΌ := sorry | [['NormedAddCommGroup', 'toAddCommGroup'], ['NontriviallyNormedField', 'toNormedField'], ['SeminormedAddCommGroup', 'toPseudoMetricSpace'], ['PseudoMetricSpace', 'toUniformSpace'], ['Field', 'toSemifield'], ['AddCommGroup', 'toAddCommMonoid'], ['RingHom', 'id'], ['NormedField', 'toField'], ['DivisionSemiring', 'toSemiring'], ['Semiring', 'toNonAssocSemiring'], ['ContinuousLinearMap'], ['ContinuousLinearMap', 'funLike'], ['NormedAddCommGroup', 'toSeminormedAddCommGroup'], ['Semifield', 'toDivisionSemiring'], ['DFunLike', 'coe'], ['UniformSpace', 'toTopologicalSpace'], ['NormedSpace', 'toModule'], ['AEMeasurable']] | @[measurability]
theorem AEMeasurable.apply_continuousLinearMap {Ο : Ξ± β F βL[π] E} {ΞΌ : Measure Ξ±}
(hΟ : AEMeasurable Ο ΞΌ) (v : F) : AEMeasurable (fun a => Ο a v) ΞΌ :=
(ContinuousLinearMap.apply π E v).measurable.comp_aemeasurable hΟ | [['ContinuousLinearMap', 'apply'], ['NontriviallyNormedField', 'toNormedField'], ['AddCommGroup', 'toAddCommMonoid'], ['ContinuousLinearMap', 'toNormedAddCommGroup'], ['Semifield', 'toCommGroupWithZero'], ['SeminormedCommRing', 'toSeminormedRing'], ['Semiring', 'toNonAssocSemiring'], ['SMulWithZero', 'toSMulZeroClass'], ['MulActionWithZero', 'toMulAction'], ['NormedRing', 'toRing'], ['TopologicalAddGroup', 'toContinuousAdd'], ['ContinuousLinearMap', 'topologicalSpace'], ['ContinuousLinearMap', 'instBorelSpace'], ['smulCommClass_self'], ['PseudoMetricSpace', 'toUniformSpace'], ['NormedCommRing', 'toNormedRing'], ['Module', 'toMulActionWithZero'], ['EuclideanDomain', 'toCommRing'], ['CommGroupWithZero', 'toCommMonoidWithZero'], ['SMulZeroClass', 'toSMul'], ['CommRing', 'toCommMonoid'], ['MulActionWithZero', 'toSMulWithZero'], ['ContinuousLinearMap'], ['Field', 'toEuclideanDomain'], ['NormedAddCommGroup', 'toSeminormedAddCommGroup'], ['NormedSpace', 'toModule'], ['MonoidWithZero', 'toZero'], ['SeminormedAddCommGroup', 'toSeminormedAddGroup'], ['BoundedSMul', 'continuousSMul'], ['NormedAddCommGroup', 'toAddCommGroup'], ['AddCommGroup', 'toDivisionAddCommMonoid'], ['SeminormedAddCommGroup', 'toTopologicalAddGroup'], ['CommMonoidWithZero', 'toZero'], ['Semiring', 'toMonoidWithZero'], ['ContinuousLinearMap', 'toNormedSpace'], ['SeminormedRing', 'toPseudoMetricSpace'], ['AddCommMonoid', 'toAddMonoid'], ['SubtractionCommMonoid', 'toSubtractionMonoid'], ['SeminormedAddGroup', 'toAddGroup'], ['RingHom', 'id'], ['ContinuousLinearMap', 'module'], ['BorelSpace', 'opensMeasurable'], ['NormedField', 'toField'], ['Field', 'toCommRing'], ['ContinuousLinearMap', 'addCommGroup'], ['SeminormedAddCommGroup', 'toAddCommGroup'], ['ContinuousLinearMap', 'funLike'], ['AddMonoid', 'toZero'], ['NormedSpace', 'boundedSMul'], ['Measurable', 'comp_aemeasurable'], ['DFunLike', 'coe'], ['UniformSpace', 'toTopologicalSpace'], ['ContinuousLinearMap', 'measurable'], ['SubtractionMonoid', 'toSubNegZeroMonoid'], ['SeminormedAddCommGroup', 'toPseudoMetricSpace'], ['Field', 'toSemifield'], ['ContinuousSMul', 'continuousConstSMul'], ['SubNegZeroMonoid', 'toNegZeroClass'], ['NormedField', 'toNormedCommRing'], ['ContinuousLinearMap', 'instMeasurableSpace'], ['NormedCommRing', 'toSeminormedCommRing'], ['DivisionSemiring', 'toSemiring'], ['RingHomIsometric', 'ids'], ['Semifield', 'toDivisionSemiring'], ['ContinuousLinearMap', 'addCommMonoid'], ['NegZeroClass', 'toZero']] | theorem | Syntax(original=True, range=StringRange(start=2515, stop=2775)) | True | ['Mathlib', 'MeasureTheory', 'Constructions', 'BorelSpace', 'ContinuousLinearMap'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
measurable_smul_const | import Init
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.Analysis.NormedSpace.OperatorNorm.NormedSpace
import Mathlib.Topology.Algebra.Module.FiniteDimension
import Mathlib.MeasureTheory.Constructions.BorelSpace.ContinuousLinearMap
open MeasureTheory
| import Init
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.Analysis.NormedSpace.OperatorNorm.NormedSpace
import Mathlib.Topology.Algebra.Module.FiniteDimension
import Mathlib.MeasureTheory.Constructions.BorelSpace.ContinuousLinearMap
| open MeasureTheory
| theorem measurable_smul_const {f : Ξ± β π} {c : E} (hc : c β 0) :
(Measurable fun x => f x β’ c) β Measurable f := sorry | theorem measurable_smul_const_extracted : β {Ξ± : Type u_1} [inst : MeasurableSpace Ξ±] {π : Type u_2} [inst_1 : NontriviallyNormedField π]
[inst_2 : CompleteSpace π] [inst_3 : MeasurableSpace π] [inst_4 : BorelSpace π] {E : Type u_3}
[inst_5 : NormedAddCommGroup E] [inst_6 : NormedSpace π E] [inst_7 : MeasurableSpace E] [inst_8 : BorelSpace E]
{f : Ξ± β π} {c : E}, c β 0 β ((Measurable fun x => f x β’ c) β Measurable f) := sorry | [['NormedAddCommGroup', 'toAddCommGroup'], ['AddCommGroup', 'toDivisionAddCommMonoid'], ['CommMonoidWithZero', 'toZero'], ['instHSMul'], ['NontriviallyNormedField', 'toNormedField'], ['Semiring', 'toMonoidWithZero'], ['AddCommGroup', 'toAddCommMonoid'], ['Field', 'toSemifield'], ['Semifield', 'toCommGroupWithZero'], ['Module', 'toMulActionWithZero'], ['SubNegZeroMonoid', 'toNegZeroClass'], ['SubtractionCommMonoid', 'toSubtractionMonoid'], ['CommGroupWithZero', 'toCommMonoidWithZero'], ['SMulZeroClass', 'toSMul'], ['NormedField', 'toField'], ['DivisionSemiring', 'toSemiring'], ['MulActionWithZero', 'toSMulWithZero'], ['SMulWithZero', 'toSMulZeroClass'], ['Iff'], ['NormedAddCommGroup', 'toSeminormedAddCommGroup'], ['HSMul', 'hSMul'], ['Semifield', 'toDivisionSemiring'], ['Measurable'], ['NormedSpace', 'toModule'], ['NegZeroClass', 'toZero'], ['SubtractionMonoid', 'toSubNegZeroMonoid']] | theorem measurable_smul_const {f : Ξ± β π} {c : E} (hc : c β 0) :
(Measurable fun x => f x β’ c) β Measurable f :=
(closedEmbedding_smul_left hc).measurableEmbedding.measurable_comp_iff | [['NormedAddCommGroup', 'toAddCommGroup'], ['SeminormedAddCommGroup', 'toTopologicalAddGroup'], ['CommMonoidWithZero', 'toZero'], ['AddCommGroup', 'toDivisionAddCommMonoid'], ['instHSMul'], ['NontriviallyNormedField', 'toNormedField'], ['ClosedEmbedding', 'measurableEmbedding'], ['Semiring', 'toMonoidWithZero'], ['AddCommGroup', 'toAddCommMonoid'], ['SeminormedRing', 'toPseudoMetricSpace'], ['MeasurableEmbedding', 'measurable_comp_iff'], ['Semifield', 'toCommGroupWithZero'], ['SubtractionCommMonoid', 'toSubtractionMonoid'], ['MetricSpace', 'toMetrizableSpace'], ['NormedField', 'toField'], ['SMulWithZero', 'toSMulZeroClass'], ['SeminormedCommRing', 'toSeminormedRing'], ['NormedSpace', 'boundedSMul'], ['HSMul', 'hSMul'], ['UniformSpace', 'toTopologicalSpace'], ['SubtractionMonoid', 'toSubNegZeroMonoid'], ['TopologicalSpace', 't2Space_of_metrizableSpace'], ['closedEmbedding_smul_left'], ['SeminormedAddCommGroup', 'toPseudoMetricSpace'], ['PseudoMetricSpace', 'toUniformSpace'], ['Field', 'toSemifield'], ['SubNegZeroMonoid', 'toNegZeroClass'], ['Module', 'toMulActionWithZero'], ['NormedField', 'toNormedCommRing'], ['CommGroupWithZero', 'toCommMonoidWithZero'], ['SMulZeroClass', 'toSMul'], ['NormedAddCommGroup', 'toMetricSpace'], ['DivisionSemiring', 'toSemiring'], ['NormedCommRing', 'toSeminormedCommRing'], ['MulActionWithZero', 'toSMulWithZero'], ['NormedAddCommGroup', 'toSeminormedAddCommGroup'], ['Semifield', 'toDivisionSemiring'], ['NormedSpace', 'toModule'], ['BoundedSMul', 'continuousSMul'], ['NegZeroClass', 'toZero']] | theorem | Syntax(original=True, range=StringRange(start=3066, stop=3267)) | True | ['Mathlib', 'MeasureTheory', 'Constructions', 'BorelSpace', 'ContinuousLinearMap'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
aemeasurable_smul_const | import Init
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.Analysis.NormedSpace.OperatorNorm.NormedSpace
import Mathlib.Topology.Algebra.Module.FiniteDimension
import Mathlib.MeasureTheory.Constructions.BorelSpace.ContinuousLinearMap
open MeasureTheory
| import Init
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.Analysis.NormedSpace.OperatorNorm.NormedSpace
import Mathlib.Topology.Algebra.Module.FiniteDimension
import Mathlib.MeasureTheory.Constructions.BorelSpace.ContinuousLinearMap
| open MeasureTheory
| theorem aemeasurable_smul_const {f : Ξ± β π} {ΞΌ : Measure Ξ±} {c : E} (hc : c β 0) :
AEMeasurable (fun x => f x β’ c) ΞΌ β AEMeasurable f ΞΌ := sorry | theorem aemeasurable_smul_const_extracted : β {Ξ± : Type u_1} [inst : MeasurableSpace Ξ±] {π : Type u_2} [inst_1 : NontriviallyNormedField π]
[inst_2 : CompleteSpace π] [inst_3 : MeasurableSpace π] [inst_4 : BorelSpace π] {E : Type u_3}
[inst_5 : NormedAddCommGroup E] [inst_6 : NormedSpace π E] [inst_7 : MeasurableSpace E] [inst_8 : BorelSpace E]
{f : Ξ± β π} {ΞΌ : Measure Ξ±} {c : E}, c β 0 β (AEMeasurable (fun x => f x β’ c) ΞΌ β AEMeasurable f ΞΌ) := sorry | [['NormedAddCommGroup', 'toAddCommGroup'], ['AddCommGroup', 'toDivisionAddCommMonoid'], ['CommMonoidWithZero', 'toZero'], ['instHSMul'], ['NontriviallyNormedField', 'toNormedField'], ['Semiring', 'toMonoidWithZero'], ['AddCommGroup', 'toAddCommMonoid'], ['Field', 'toSemifield'], ['Semifield', 'toCommGroupWithZero'], ['Module', 'toMulActionWithZero'], ['SubNegZeroMonoid', 'toNegZeroClass'], ['SubtractionCommMonoid', 'toSubtractionMonoid'], ['CommGroupWithZero', 'toCommMonoidWithZero'], ['SMulZeroClass', 'toSMul'], ['NormedField', 'toField'], ['DivisionSemiring', 'toSemiring'], ['MulActionWithZero', 'toSMulWithZero'], ['SMulWithZero', 'toSMulZeroClass'], ['Iff'], ['NormedAddCommGroup', 'toSeminormedAddCommGroup'], ['HSMul', 'hSMul'], ['Semifield', 'toDivisionSemiring'], ['NormedSpace', 'toModule'], ['NegZeroClass', 'toZero'], ['AEMeasurable'], ['SubtractionMonoid', 'toSubNegZeroMonoid']] | theorem aemeasurable_smul_const {f : Ξ± β π} {ΞΌ : Measure Ξ±} {c : E} (hc : c β 0) :
AEMeasurable (fun x => f x β’ c) ΞΌ β AEMeasurable f ΞΌ :=
(closedEmbedding_smul_left hc).measurableEmbedding.aemeasurable_comp_iff | [['NormedAddCommGroup', 'toAddCommGroup'], ['SeminormedAddCommGroup', 'toTopologicalAddGroup'], ['CommMonoidWithZero', 'toZero'], ['AddCommGroup', 'toDivisionAddCommMonoid'], ['instHSMul'], ['NontriviallyNormedField', 'toNormedField'], ['ClosedEmbedding', 'measurableEmbedding'], ['Semiring', 'toMonoidWithZero'], ['AddCommGroup', 'toAddCommMonoid'], ['SeminormedRing', 'toPseudoMetricSpace'], ['Semifield', 'toCommGroupWithZero'], ['SubtractionCommMonoid', 'toSubtractionMonoid'], ['MetricSpace', 'toMetrizableSpace'], ['NormedField', 'toField'], ['SMulWithZero', 'toSMulZeroClass'], ['SeminormedCommRing', 'toSeminormedRing'], ['NormedSpace', 'boundedSMul'], ['HSMul', 'hSMul'], ['UniformSpace', 'toTopologicalSpace'], ['SubtractionMonoid', 'toSubNegZeroMonoid'], ['TopologicalSpace', 't2Space_of_metrizableSpace'], ['closedEmbedding_smul_left'], ['SeminormedAddCommGroup', 'toPseudoMetricSpace'], ['PseudoMetricSpace', 'toUniformSpace'], ['Field', 'toSemifield'], ['SubNegZeroMonoid', 'toNegZeroClass'], ['Module', 'toMulActionWithZero'], ['NormedField', 'toNormedCommRing'], ['CommGroupWithZero', 'toCommMonoidWithZero'], ['SMulZeroClass', 'toSMul'], ['NormedAddCommGroup', 'toMetricSpace'], ['MeasurableEmbedding', 'aemeasurable_comp_iff'], ['DivisionSemiring', 'toSemiring'], ['NormedCommRing', 'toSeminormedCommRing'], ['MulActionWithZero', 'toSMulWithZero'], ['NormedAddCommGroup', 'toSeminormedAddCommGroup'], ['Semifield', 'toDivisionSemiring'], ['NormedSpace', 'toModule'], ['BoundedSMul', 'continuousSMul'], ['NegZeroClass', 'toZero']] | theorem | Syntax(original=True, range=StringRange(start=3269, stop=3502)) | True | ['Mathlib', 'MeasureTheory', 'Constructions', 'BorelSpace', 'ContinuousLinearMap'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
ProbabilityTheory.termπΌ[_|_] | import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
open MeasureTheory
open scoped MeasureTheory
| import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
| open MeasureTheory
open scoped MeasureTheory
| scoped[ProbabilityTheory] notation "πΌ[" X "|" m "]" =>
MeasureTheory.condexp m MeasureTheory.MeasureSpace.volume X := sorry | def termπΌ[_|_]_extracted : Lean.ParserDescr := sorry | [['Lean', 'ParserDescr']] | scoped[ProbabilityTheory] notation "πΌ[" X "|" m "]" =>
MeasureTheory.condexp m MeasureTheory.MeasureSpace.volume X | [['Lean', 'ParserDescr', 'binary'], ['Lean', 'Name', 'mkStr2'], ['OfNat', 'ofNat'], ['Lean', 'ParserDescr', 'cat'], ['Lean', 'ParserDescr', 'node'], ['instOfNatNat'], ['Lean', 'Name', 'mkStr1'], ['Nat'], ['Lean', 'ParserDescr', 'symbol']] | theorem | Syntax(original=False, range=StringRange(start=1468, stop=1587)) | True | ['Mathlib', 'Probability', 'Notation'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
ProbabilityTheory._aux___macroRules_ProbabilityTheory_termπΌ[_|_]_1 | import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
open MeasureTheory
open scoped MeasureTheory
| import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
| open MeasureTheory
open scoped MeasureTheory
| scoped[ProbabilityTheory] notation "πΌ[" X "|" m "]" =>
MeasureTheory.condexp m MeasureTheory.MeasureSpace.volume X := sorry | def _aux___macroRules_ProbabilityTheory_termπΌ[_|_]_1_extracted : Lean.Macro := sorry | [['Lean', 'Macro']] | scoped[ProbabilityTheory] notation "πΌ[" X "|" m "]" =>
MeasureTheory.condexp m MeasureTheory.MeasureSpace.volume X | [['EStateM'], ['OfNat', 'ofNat'], ['Lean', 'Name', 'mkStr3'], ['String', "toSubstring'"], ['Lean', 'MacroM'], ['String'], ['Lean', 'Syntax', 'Preresolved', 'decl'], ['Lean', 'Macro', 'instMonadQuotationMacroM'], ['Lean', 'Name', 'mkStr1'], ['Lean', 'Syntax', 'Preresolved'], ['Lean', 'addMacroScope'], ['Pure', 'pure'], ['Monad', 'toBind'], ['Lean', 'Macro', 'instMonadRefMacroM'], ['Eq'], ['ite'], ['Lean', 'TSyntax'], ['EStateM', 'instMonad'], ['Lean', 'MonadQuotation', 'getCurrMacroScope'], ['Lean', 'Macro', 'State'], ['Bool', 'true'], ['PUnit'], ['Lean', 'Macro', 'Exception'], ['instOfNatNat'], ['Lean', 'Syntax', 'ident'], ['List', 'nil'], ['Nat'], ['Bind', 'bind'], ['Lean', 'Syntax', 'node3'], ['Applicative', 'toPure'], ['instDecidableEqBool'], ['Lean', 'Syntax', 'node2'], ['List', 'cons'], ['Lean', 'Syntax', 'isOfKind'], ['Lean', 'Macro', 'Context'], ['Lean', 'Name', 'mkStr4'], ['Lean', 'TSyntax', 'raw'], ['Lean', 'TSyntax', 'mk'], ['instMonadExceptOfMonadExceptOf'], ['ReaderT', 'instMonadExceptOf'], ['Lean', 'Syntax', 'getArg'], ['Lean', 'Syntax'], ['Lean', 'Macro', 'Exception', 'unsupportedSyntax'], ['EStateM', 'instMonadExceptOfOfBacktrackable'], ['Lean', 'MacroScope'], ['Lean', 'MonadRef', 'mkInfoFromRefPos'], ['ReaderT', 'instApplicativeOfMonad'], ['Lean', 'Name', 'mkStr2'], ['Lean', 'MonadQuotation', 'getMainModule'], ['Lean', 'SyntaxNodeKind'], ['letFun'], ['EStateM', 'nonBacktrackable'], ['MonadExcept', 'throw'], ['Lean', 'SourceInfo'], ['Bool'], ['ReaderT', 'instMonad'], ['Lean', 'Name']] | theorem | Syntax(original=False, range=StringRange(start=1468, stop=1587)) | True | ['Mathlib', 'Probability', 'Notation'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
ProbabilityTheory._aux___unexpand_MeasureTheory_condexp_1 | import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
open MeasureTheory
open scoped MeasureTheory
| import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
| open MeasureTheory
open scoped MeasureTheory
| scoped[ProbabilityTheory] notation "πΌ[" X "|" m "]" =>
MeasureTheory.condexp m MeasureTheory.MeasureSpace.volume X := sorry | def _aux___unexpand_MeasureTheory_condexp_1_extracted : Lean.PrettyPrinter.Unexpander := sorry | [['Lean', 'PrettyPrinter', 'Unexpander']] | scoped[ProbabilityTheory] notation "πΌ[" X "|" m "]" =>
MeasureTheory.condexp m MeasureTheory.MeasureSpace.volume X | [['Lean', 'withRef'], ['Lean', 'Syntax', 'matchesNull'], ['EStateM'], ['cond'], ['OfNat', 'ofNat'], ['Lean', 'Name', 'mkStr3'], ['Lean', 'Name', 'mkStr1'], ['Pure', 'pure'], ['Monad', 'toBind'], ['Eq'], ['ite'], ['Lean', 'TSyntax'], ['EStateM', 'instMonad'], ['Lean', 'MonadQuotation', 'getCurrMacroScope'], ['Bool', 'true'], ['Unit', 'unit'], ['PUnit'], ['instOfNatNat'], ['List', 'nil'], ['Bind', 'bind'], ['Nat'], ['Applicative', 'toPure'], ['instDecidableEqBool'], ['Lean', 'PrettyPrinter', 'instMonadQuotationUnexpandM'], ['Lean', 'Syntax', 'isOfKind'], ['List', 'cons'], ['Lean', 'Name', 'mkStr4'], ['Unit'], ['Lean', 'TSyntax', 'raw'], ['Lean', 'Syntax', 'matchesIdent'], ['Lean', 'TSyntax', 'mk'], ['Lean', 'MonadQuotation', 'toMonadRef'], ['instMonadExceptOfMonadExceptOf'], ['Lean', 'Syntax', 'atom'], ['Lean', 'Syntax', 'node5'], ['ReaderT', 'instMonadExceptOf'], ['Lean', 'Syntax', 'getArg'], ['Lean', 'Syntax'], ['EStateM', 'instMonadExceptOfOfBacktrackable'], ['Lean', 'MacroScope'], ['Lean', 'MonadRef', 'mkInfoFromRefPos'], ['or'], ['Lean', 'Name', 'mkStr2'], ['ReaderT', 'instApplicativeOfMonad'], ['Lean', 'MonadQuotation', 'getMainModule'], ['Bool', 'false'], ['Lean', 'PrettyPrinter', 'UnexpandM'], ['letFun'], ['Lean', 'SyntaxNodeKind'], ['EStateM', 'nonBacktrackable'], ['MonadExcept', 'throw'], ['Lean', 'SourceInfo'], ['Bool'], ['ReaderT', 'instMonad'], ['Lean', 'Name']] | theorem | Syntax(original=False, range=StringRange(start=1468, stop=1587)) | True | ['Mathlib', 'Probability', 'Notation'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
ProbabilityTheory.term_[_] | import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
open MeasureTheory
open scoped MeasureTheory
| import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
| open MeasureTheory
open scoped MeasureTheory
| scoped[ProbabilityTheory] notation P "[" X "]" => β« x, β(X x) βP := sorry | def term_[_]_extracted : Lean.TrailingParserDescr := sorry | [['Lean', 'TrailingParserDescr']] | scoped[ProbabilityTheory] notation P "[" X "]" => β« x, β(X x) βP | [['Lean', 'ParserDescr', 'binary'], ['Lean', 'Name', 'mkStr2'], ['OfNat', 'ofNat'], ['Lean', 'ParserDescr', 'cat'], ['Lean', 'ParserDescr', 'trailingNode'], ['instOfNatNat'], ['Lean', 'Name', 'mkStr1'], ['Nat'], ['Lean', 'ParserDescr', 'symbol']] | theorem | Syntax(original=False, range=StringRange(start=1702, stop=1772)) | True | ['Mathlib', 'Probability', 'Notation'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
ProbabilityTheory._aux___macroRules_ProbabilityTheory_term_[_]_1 | import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
open MeasureTheory
open scoped MeasureTheory
| import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
| open MeasureTheory
open scoped MeasureTheory
| scoped[ProbabilityTheory] notation P "[" X "]" => β« x, β(X x) βP := sorry | def _aux___macroRules_ProbabilityTheory_term_[_]_1_extracted : Lean.Macro := sorry | [['Lean', 'Macro']] | scoped[ProbabilityTheory] notation P "[" X "]" => β« x, β(X x) βP | [['EStateM'], ['OfNat', 'ofNat'], ['Array', 'mkArray0'], ['Lean', 'Name', 'mkStr3'], ['String', "toSubstring'"], ['Lean', 'MacroM'], ['Lean', 'Macro', 'instMonadQuotationMacroM'], ['Lean', 'Name', 'mkStr1'], ['Lean', 'Syntax', 'Preresolved'], ['Lean', 'addMacroScope'], ['Pure', 'pure'], ['Monad', 'toBind'], ['Lean', 'Macro', 'instMonadRefMacroM'], ['Eq'], ['ite'], ['Lean', 'TSyntax'], ['EStateM', 'instMonad'], ['Lean', 'MonadQuotation', 'getCurrMacroScope'], ['Lean', 'Syntax', 'node1'], ['Lean', 'Macro', 'State'], ['Bool', 'true'], ['PUnit'], ['Lean', 'Macro', 'Exception'], ['instOfNatNat'], ['Lean', 'Syntax', 'ident'], ['List', 'nil'], ['Nat'], ['Bind', 'bind'], ['Lean', 'Syntax', 'node3'], ['Applicative', 'toPure'], ['instDecidableEqBool'], ['Lean', 'Syntax', 'node2'], ['List', 'cons'], ['Lean', 'Syntax', 'isOfKind'], ['Lean', 'Macro', 'Context'], ['Lean', 'Name', 'mkStr4'], ['Lean', 'TSyntax', 'raw'], ['Lean', 'TSyntax', 'mk'], ['instMonadExceptOfMonadExceptOf'], ['Lean', 'Syntax', 'atom'], ['ReaderT', 'instMonadExceptOf'], ['Lean', 'Syntax', 'node6'], ['Lean', 'Syntax', 'getArg'], ['Lean', 'Syntax'], ['Lean', 'Macro', 'Exception', 'unsupportedSyntax'], ['EStateM', 'instMonadExceptOfOfBacktrackable'], ['Lean', 'Syntax', 'node'], ['Lean', 'MacroScope'], ['Lean', 'MonadRef', 'mkInfoFromRefPos'], ['ReaderT', 'instApplicativeOfMonad'], ['Lean', 'Name', 'mkStr2'], ['Lean', 'MonadQuotation', 'getMainModule'], ['Lean', 'SyntaxNodeKind'], ['letFun'], ['EStateM', 'nonBacktrackable'], ['MonadExcept', 'throw'], ['Lean', 'SourceInfo'], ['Bool'], ['ReaderT', 'instMonad'], ['Lean', 'Name']] | theorem | Syntax(original=False, range=StringRange(start=1702, stop=1772)) | True | ['Mathlib', 'Probability', 'Notation'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
ProbabilityTheory.termπΌ[_] | import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
open MeasureTheory
open scoped MeasureTheory
| import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
| open MeasureTheory
open scoped MeasureTheory
| scoped[ProbabilityTheory] notation "πΌ[" X "]" => β« a, (X : _ β _) a := sorry | def termπΌ[_]_extracted : Lean.ParserDescr := sorry | [['Lean', 'ParserDescr']] | scoped[ProbabilityTheory] notation "πΌ[" X "]" => β« a, (X : _ β _) a | [['Lean', 'ParserDescr', 'binary'], ['Lean', 'Name', 'mkStr2'], ['OfNat', 'ofNat'], ['Lean', 'ParserDescr', 'cat'], ['Lean', 'ParserDescr', 'node'], ['instOfNatNat'], ['Lean', 'Name', 'mkStr1'], ['Nat'], ['Lean', 'ParserDescr', 'symbol']] | theorem | Syntax(original=False, range=StringRange(start=1774, stop=1848)) | True | ['Mathlib', 'Probability', 'Notation'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
ProbabilityTheory._aux___macroRules_ProbabilityTheory_termπΌ[_]_1 | import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
open MeasureTheory
open scoped MeasureTheory
| import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
| open MeasureTheory
open scoped MeasureTheory
| scoped[ProbabilityTheory] notation "πΌ[" X "]" => β« a, (X : _ β _) a := sorry | def _aux___macroRules_ProbabilityTheory_termπΌ[_]_1_extracted : Lean.Macro := sorry | [['Lean', 'Macro']] | scoped[ProbabilityTheory] notation "πΌ[" X "]" => β« a, (X : _ β _) a | [['EStateM'], ['OfNat', 'ofNat'], ['Array', 'mkArray0'], ['Lean', 'Name', 'mkStr3'], ['String', "toSubstring'"], ['Lean', 'MacroM'], ['Lean', 'Macro', 'instMonadQuotationMacroM'], ['Lean', 'Name', 'mkStr1'], ['Lean', 'Syntax', 'Preresolved'], ['Lean', 'addMacroScope'], ['Lean', 'Syntax', 'node4'], ['Pure', 'pure'], ['Monad', 'toBind'], ['Lean', 'Macro', 'instMonadRefMacroM'], ['Eq'], ['ite'], ['Lean', 'TSyntax'], ['EStateM', 'instMonad'], ['Lean', 'MonadQuotation', 'getCurrMacroScope'], ['Lean', 'Syntax', 'node1'], ['Lean', 'Macro', 'State'], ['Bool', 'true'], ['PUnit'], ['Lean', 'Macro', 'Exception'], ['instOfNatNat'], ['Lean', 'Syntax', 'ident'], ['List', 'nil'], ['Nat'], ['Bind', 'bind'], ['Lean', 'Syntax', 'node3'], ['Applicative', 'toPure'], ['instDecidableEqBool'], ['Lean', 'Syntax', 'node2'], ['List', 'cons'], ['Lean', 'Syntax', 'isOfKind'], ['Lean', 'Macro', 'Context'], ['Lean', 'Name', 'mkStr4'], ['Lean', 'TSyntax', 'raw'], ['Lean', 'TSyntax', 'mk'], ['instMonadExceptOfMonadExceptOf'], ['Lean', 'Syntax', 'atom'], ['Lean', 'Syntax', 'node5'], ['ReaderT', 'instMonadExceptOf'], ['Lean', 'Syntax', 'getArg'], ['Lean', 'Syntax'], ['Lean', 'Macro', 'Exception', 'unsupportedSyntax'], ['EStateM', 'instMonadExceptOfOfBacktrackable'], ['Lean', 'Syntax', 'node'], ['Lean', 'MacroScope'], ['Lean', 'MonadRef', 'mkInfoFromRefPos'], ['ReaderT', 'instApplicativeOfMonad'], ['Lean', 'Name', 'mkStr2'], ['Lean', 'MonadQuotation', 'getMainModule'], ['Lean', 'SyntaxNodeKind'], ['letFun'], ['EStateM', 'nonBacktrackable'], ['MonadExcept', 'throw'], ['Lean', 'SourceInfo'], ['Bool'], ['ReaderT', 'instMonad'], ['Lean', 'Name']] | theorem | Syntax(original=False, range=StringRange(start=1774, stop=1848)) | True | ['Mathlib', 'Probability', 'Notation'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
ProbabilityTheory.term_β¦_|_β§ | import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
open MeasureTheory
open scoped MeasureTheory
| import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
| open MeasureTheory
open scoped MeasureTheory
| scoped[ProbabilityTheory] notation P "β¦" s "|" m "β§" =>
MeasureTheory.condexp m P (Set.indicator s fun Ο => (1 : β)) := sorry | def term_β¦_|_β§_extracted : Lean.TrailingParserDescr := sorry | [['Lean', 'TrailingParserDescr']] | scoped[ProbabilityTheory] notation P "β¦" s "|" m "β§" =>
MeasureTheory.condexp m P (Set.indicator s fun Ο => (1 : β)) | [['Lean', 'ParserDescr', 'binary'], ['Lean', 'Name', 'mkStr2'], ['OfNat', 'ofNat'], ['Lean', 'ParserDescr', 'cat'], ['Lean', 'ParserDescr', 'trailingNode'], ['instOfNatNat'], ['Lean', 'Name', 'mkStr1'], ['Nat'], ['Lean', 'ParserDescr', 'symbol']] | theorem | Syntax(original=False, range=StringRange(start=1850, stop=1975)) | True | ['Mathlib', 'Probability', 'Notation'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
ProbabilityTheory._aux___macroRules_ProbabilityTheory_term_β¦_|_β§_1 | import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
open MeasureTheory
open scoped MeasureTheory
| import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
| open MeasureTheory
open scoped MeasureTheory
| scoped[ProbabilityTheory] notation P "β¦" s "|" m "β§" =>
MeasureTheory.condexp m P (Set.indicator s fun Ο => (1 : β)) := sorry | def _aux___macroRules_ProbabilityTheory_term_β¦_|_β§_1_extracted : Lean.Macro := sorry | [['Lean', 'Macro']] | scoped[ProbabilityTheory] notation P "β¦" s "|" m "β§" =>
MeasureTheory.condexp m P (Set.indicator s fun Ο => (1 : β)) | [['EStateM'], ['OfNat', 'ofNat'], ['Array', 'mkArray0'], ['String', "toSubstring'"], ['Lean', 'MacroM'], ['String'], ['Lean', 'Syntax', 'Preresolved', 'decl'], ['Lean', 'Macro', 'instMonadQuotationMacroM'], ['Lean', 'Name', 'mkStr1'], ['Lean', 'Syntax', 'Preresolved'], ['Lean', 'Syntax', 'node4'], ['Lean', 'addMacroScope'], ['Pure', 'pure'], ['Lean', 'Syntax', 'Preresolved', 'namespace'], ['Monad', 'toBind'], ['Lean', 'Macro', 'instMonadRefMacroM'], ['Eq'], ['ite'], ['Lean', 'TSyntax'], ['EStateM', 'instMonad'], ['Lean', 'MonadQuotation', 'getCurrMacroScope'], ['Lean', 'Syntax', 'node1'], ['Lean', 'Macro', 'State'], ['Bool', 'true'], ['PUnit'], ['Lean', 'Macro', 'Exception'], ['instOfNatNat'], ['Lean', 'Syntax', 'ident'], ['List', 'nil'], ['Nat'], ['Bind', 'bind'], ['Lean', 'Syntax', 'node3'], ['Applicative', 'toPure'], ['instDecidableEqBool'], ['Lean', 'Syntax', 'node2'], ['List', 'cons'], ['Lean', 'Syntax', 'isOfKind'], ['Lean', 'Macro', 'Context'], ['Lean', 'Name', 'mkStr4'], ['Lean', 'TSyntax', 'raw'], ['Lean', 'TSyntax', 'mk'], ['instMonadExceptOfMonadExceptOf'], ['Lean', 'Syntax', 'atom'], ['Lean', 'Syntax', 'node5'], ['ReaderT', 'instMonadExceptOf'], ['Lean', 'Syntax', 'getArg'], ['Lean', 'Syntax'], ['Lean', 'Macro', 'Exception', 'unsupportedSyntax'], ['EStateM', 'instMonadExceptOfOfBacktrackable'], ['Lean', 'Syntax', 'node'], ['Lean', 'MacroScope'], ['Lean', 'MonadRef', 'mkInfoFromRefPos'], ['ReaderT', 'instApplicativeOfMonad'], ['Lean', 'Name', 'mkStr2'], ['Lean', 'MonadQuotation', 'getMainModule'], ['Lean', 'SyntaxNodeKind'], ['letFun'], ['EStateM', 'nonBacktrackable'], ['MonadExcept', 'throw'], ['Lean', 'SourceInfo'], ['Bool'], ['ReaderT', 'instMonad'], ['Lean', 'Name']] | theorem | Syntax(original=False, range=StringRange(start=1850, stop=1975)) | True | ['Mathlib', 'Probability', 'Notation'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
ProbabilityTheory._aux___unexpand_MeasureTheory_condexp_2 | import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
open MeasureTheory
open scoped MeasureTheory
| import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
| open MeasureTheory
open scoped MeasureTheory
| scoped[ProbabilityTheory] notation P "β¦" s "|" m "β§" =>
MeasureTheory.condexp m P (Set.indicator s fun Ο => (1 : β)) := sorry | def _aux___unexpand_MeasureTheory_condexp_2_extracted : Lean.PrettyPrinter.Unexpander := sorry | [['Lean', 'PrettyPrinter', 'Unexpander']] | scoped[ProbabilityTheory] notation P "β¦" s "|" m "β§" =>
MeasureTheory.condexp m P (Set.indicator s fun Ο => (1 : β)) | [['Lean', 'withRef'], ['Lean', 'Syntax', 'matchesNull'], ['Lean', 'Syntax', 'matchesLit'], ['EStateM'], ['cond'], ['OfNat', 'ofNat'], ['Lean', 'Name', 'mkStr1'], ['Pure', 'pure'], ['Monad', 'toBind'], ['Eq'], ['ite'], ['Lean', 'TSyntax'], ['EStateM', 'instMonad'], ['Lean', 'MonadQuotation', 'getCurrMacroScope'], ['Bool', 'true'], ['Unit', 'unit'], ['PUnit'], ['instOfNatNat'], ['List', 'nil'], ['Bind', 'bind'], ['Nat'], ['Applicative', 'toPure'], ['instDecidableEqBool'], ['Lean', 'PrettyPrinter', 'instMonadQuotationUnexpandM'], ['Lean', 'Syntax', 'isOfKind'], ['List', 'cons'], ['Lean', 'Name', 'mkStr4'], ['Unit'], ['Lean', 'TSyntax', 'raw'], ['Lean', 'Syntax', 'matchesIdent'], ['Lean', 'TSyntax', 'mk'], ['Lean', 'MonadQuotation', 'toMonadRef'], ['instMonadExceptOfMonadExceptOf'], ['Lean', 'Syntax', 'atom'], ['ReaderT', 'instMonadExceptOf'], ['Lean', 'Syntax', 'node6'], ['Lean', 'Syntax', 'getArg'], ['Lean', 'Syntax'], ['EStateM', 'instMonadExceptOfOfBacktrackable'], ['Lean', 'MacroScope'], ['Lean', 'MonadRef', 'mkInfoFromRefPos'], ['or'], ['ReaderT', 'instApplicativeOfMonad'], ['Lean', 'Name', 'mkStr2'], ['Lean', 'MonadQuotation', 'getMainModule'], ['Bool', 'false'], ['Lean', 'PrettyPrinter', 'UnexpandM'], ['letFun'], ['Lean', 'SyntaxNodeKind'], ['EStateM', 'nonBacktrackable'], ['MonadExcept', 'throw'], ['Lean', 'SourceInfo'], ['Bool'], ['ReaderT', 'instMonad'], ['Lean', 'Name']] | theorem | Syntax(original=False, range=StringRange(start=1850, stop=1975)) | True | ['Mathlib', 'Probability', 'Notation'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
ProbabilityTheory.term_=ββ_ | import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
open MeasureTheory
open scoped MeasureTheory
| import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
| open MeasureTheory
open scoped MeasureTheory
| scoped[ProbabilityTheory] notation:50 X " =ββ " Y:50 => X =α΅[MeasureTheory.MeasureSpace.volume] Y := sorry | def term_=ββ__extracted : Lean.TrailingParserDescr := sorry | [['Lean', 'TrailingParserDescr']] | scoped[ProbabilityTheory] notation:50 X " =ββ " Y:50 => X =α΅[MeasureTheory.MeasureSpace.volume] Y | [['Lean', 'ParserDescr', 'binary'], ['Lean', 'Name', 'mkStr2'], ['OfNat', 'ofNat'], ['Lean', 'ParserDescr', 'cat'], ['Lean', 'ParserDescr', 'trailingNode'], ['instOfNatNat'], ['Lean', 'Name', 'mkStr1'], ['Nat'], ['Lean', 'ParserDescr', 'symbol']] | theorem | Syntax(original=False, range=StringRange(start=1977, stop=2080)) | True | ['Mathlib', 'Probability', 'Notation'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
ProbabilityTheory._aux___macroRules_ProbabilityTheory_term_=ββ__1 | import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
open MeasureTheory
open scoped MeasureTheory
| import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
| open MeasureTheory
open scoped MeasureTheory
| scoped[ProbabilityTheory] notation:50 X " =ββ " Y:50 => X =α΅[MeasureTheory.MeasureSpace.volume] Y := sorry | def _aux___macroRules_ProbabilityTheory_term_=ββ__1_extracted : Lean.Macro := sorry | [['Lean', 'Macro']] | scoped[ProbabilityTheory] notation:50 X " =ββ " Y:50 => X =α΅[MeasureTheory.MeasureSpace.volume] Y | [['EStateM'], ['OfNat', 'ofNat'], ['Lean', 'Name', 'mkStr3'], ['String', "toSubstring'"], ['Lean', 'MacroM'], ['String'], ['Lean', 'Syntax', 'Preresolved', 'decl'], ['Lean', 'Macro', 'instMonadQuotationMacroM'], ['Lean', 'Name', 'mkStr1'], ['Lean', 'Syntax', 'Preresolved'], ['Lean', 'addMacroScope'], ['Pure', 'pure'], ['Monad', 'toBind'], ['Lean', 'Macro', 'instMonadRefMacroM'], ['Eq'], ['ite'], ['Lean', 'TSyntax'], ['EStateM', 'instMonad'], ['Lean', 'MonadQuotation', 'getCurrMacroScope'], ['Lean', 'Macro', 'State'], ['Bool', 'true'], ['PUnit'], ['Lean', 'Macro', 'Exception'], ['instOfNatNat'], ['Lean', 'Syntax', 'ident'], ['List', 'nil'], ['Nat'], ['Bind', 'bind'], ['Applicative', 'toPure'], ['instDecidableEqBool'], ['List', 'cons'], ['Lean', 'Syntax', 'isOfKind'], ['Lean', 'Macro', 'Context'], ['Lean', 'TSyntax', 'raw'], ['Lean', 'TSyntax', 'mk'], ['instMonadExceptOfMonadExceptOf'], ['Lean', 'Syntax', 'atom'], ['Lean', 'Syntax', 'node5'], ['ReaderT', 'instMonadExceptOf'], ['Lean', 'Syntax', 'getArg'], ['Lean', 'Syntax'], ['Lean', 'Macro', 'Exception', 'unsupportedSyntax'], ['EStateM', 'instMonadExceptOfOfBacktrackable'], ['Lean', 'MacroScope'], ['Lean', 'MonadRef', 'mkInfoFromRefPos'], ['ReaderT', 'instApplicativeOfMonad'], ['Lean', 'Name', 'mkStr2'], ['Lean', 'MonadQuotation', 'getMainModule'], ['Lean', 'SyntaxNodeKind'], ['letFun'], ['EStateM', 'nonBacktrackable'], ['MonadExcept', 'throw'], ['Lean', 'SourceInfo'], ['Bool'], ['ReaderT', 'instMonad'], ['Lean', 'Name']] | theorem | Syntax(original=False, range=StringRange(start=1977, stop=2080)) | True | ['Mathlib', 'Probability', 'Notation'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
ProbabilityTheory.term_β€ββ_ | import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
open MeasureTheory
open scoped MeasureTheory
| import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
| open MeasureTheory
open scoped MeasureTheory
| scoped[ProbabilityTheory] notation:50 X " β€ββ " Y:50 => X β€α΅[MeasureTheory.MeasureSpace.volume] Y := sorry | def term_β€ββ__extracted : Lean.TrailingParserDescr := sorry | [['Lean', 'TrailingParserDescr']] | scoped[ProbabilityTheory] notation:50 X " β€ββ " Y:50 => X β€α΅[MeasureTheory.MeasureSpace.volume] Y | [['Lean', 'ParserDescr', 'binary'], ['Lean', 'Name', 'mkStr2'], ['OfNat', 'ofNat'], ['Lean', 'ParserDescr', 'cat'], ['Lean', 'ParserDescr', 'trailingNode'], ['instOfNatNat'], ['Lean', 'Name', 'mkStr1'], ['Nat'], ['Lean', 'ParserDescr', 'symbol']] | theorem | Syntax(original=False, range=StringRange(start=2082, stop=2189)) | True | ['Mathlib', 'Probability', 'Notation'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
ProbabilityTheory._aux___macroRules_ProbabilityTheory_term_β€ββ__1 | import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
open MeasureTheory
open scoped MeasureTheory
| import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
| open MeasureTheory
open scoped MeasureTheory
| scoped[ProbabilityTheory] notation:50 X " β€ββ " Y:50 => X β€α΅[MeasureTheory.MeasureSpace.volume] Y := sorry | def _aux___macroRules_ProbabilityTheory_term_β€ββ__1_extracted : Lean.Macro := sorry | [['Lean', 'Macro']] | scoped[ProbabilityTheory] notation:50 X " β€ββ " Y:50 => X β€α΅[MeasureTheory.MeasureSpace.volume] Y | [['EStateM'], ['OfNat', 'ofNat'], ['Lean', 'Name', 'mkStr3'], ['String', "toSubstring'"], ['Lean', 'MacroM'], ['String'], ['Lean', 'Syntax', 'Preresolved', 'decl'], ['Lean', 'Macro', 'instMonadQuotationMacroM'], ['Lean', 'Name', 'mkStr1'], ['Lean', 'Syntax', 'Preresolved'], ['Lean', 'addMacroScope'], ['Pure', 'pure'], ['Monad', 'toBind'], ['Lean', 'Macro', 'instMonadRefMacroM'], ['Eq'], ['ite'], ['Lean', 'TSyntax'], ['EStateM', 'instMonad'], ['Lean', 'MonadQuotation', 'getCurrMacroScope'], ['Lean', 'Macro', 'State'], ['Bool', 'true'], ['PUnit'], ['Lean', 'Macro', 'Exception'], ['instOfNatNat'], ['Lean', 'Syntax', 'ident'], ['List', 'nil'], ['Nat'], ['Bind', 'bind'], ['Applicative', 'toPure'], ['instDecidableEqBool'], ['List', 'cons'], ['Lean', 'Syntax', 'isOfKind'], ['Lean', 'Macro', 'Context'], ['Lean', 'TSyntax', 'raw'], ['Lean', 'TSyntax', 'mk'], ['instMonadExceptOfMonadExceptOf'], ['Lean', 'Syntax', 'atom'], ['Lean', 'Syntax', 'node5'], ['ReaderT', 'instMonadExceptOf'], ['Lean', 'Syntax', 'getArg'], ['Lean', 'Syntax'], ['Lean', 'Macro', 'Exception', 'unsupportedSyntax'], ['EStateM', 'instMonadExceptOfOfBacktrackable'], ['Lean', 'MacroScope'], ['Lean', 'MonadRef', 'mkInfoFromRefPos'], ['ReaderT', 'instApplicativeOfMonad'], ['Lean', 'Name', 'mkStr2'], ['Lean', 'MonadQuotation', 'getMainModule'], ['Lean', 'SyntaxNodeKind'], ['letFun'], ['EStateM', 'nonBacktrackable'], ['MonadExcept', 'throw'], ['Lean', 'SourceInfo'], ['Bool'], ['ReaderT', 'instMonad'], ['Lean', 'Name']] | theorem | Syntax(original=False, range=StringRange(start=2082, stop=2189)) | True | ['Mathlib', 'Probability', 'Notation'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
ProbabilityTheory.termβ_/β_ | import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
open MeasureTheory
open scoped MeasureTheory
| import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
| open MeasureTheory
open scoped MeasureTheory
| scoped[ProbabilityTheory] notation "β" P "/β" Q:100 => MeasureTheory.Measure.rnDeriv P Q := sorry | def termβ_/β__extracted : Lean.ParserDescr := sorry | [['Lean', 'ParserDescr']] | scoped[ProbabilityTheory] notation "β" P "/β" Q:100 => MeasureTheory.Measure.rnDeriv P Q | [['Lean', 'ParserDescr', 'binary'], ['Lean', 'Name', 'mkStr2'], ['OfNat', 'ofNat'], ['Lean', 'ParserDescr', 'cat'], ['Lean', 'ParserDescr', 'node'], ['instOfNatNat'], ['Lean', 'Name', 'mkStr1'], ['Nat'], ['Lean', 'ParserDescr', 'symbol']] | theorem | Syntax(original=False, range=StringRange(start=2191, stop=2283)) | True | ['Mathlib', 'Probability', 'Notation'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
ProbabilityTheory._aux___macroRules_ProbabilityTheory_termβ_/β__1 | import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
open MeasureTheory
open scoped MeasureTheory
| import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
| open MeasureTheory
open scoped MeasureTheory
| scoped[ProbabilityTheory] notation "β" P "/β" Q:100 => MeasureTheory.Measure.rnDeriv P Q := sorry | def _aux___macroRules_ProbabilityTheory_termβ_/β__1_extracted : Lean.Macro := sorry | [['Lean', 'Macro']] | scoped[ProbabilityTheory] notation "β" P "/β" Q:100 => MeasureTheory.Measure.rnDeriv P Q | [['EStateM'], ['OfNat', 'ofNat'], ['Lean', 'Name', 'mkStr3'], ['String', "toSubstring'"], ['Lean', 'MacroM'], ['String'], ['Lean', 'Syntax', 'Preresolved', 'decl'], ['Lean', 'Macro', 'instMonadQuotationMacroM'], ['Lean', 'Name', 'mkStr1'], ['Lean', 'Syntax', 'Preresolved'], ['Lean', 'addMacroScope'], ['Pure', 'pure'], ['Monad', 'toBind'], ['Lean', 'Macro', 'instMonadRefMacroM'], ['Eq'], ['ite'], ['Lean', 'TSyntax'], ['EStateM', 'instMonad'], ['Lean', 'MonadQuotation', 'getCurrMacroScope'], ['Lean', 'Macro', 'State'], ['Bool', 'true'], ['PUnit'], ['Lean', 'Macro', 'Exception'], ['instOfNatNat'], ['Lean', 'Syntax', 'ident'], ['List', 'nil'], ['Nat'], ['Bind', 'bind'], ['Applicative', 'toPure'], ['instDecidableEqBool'], ['Lean', 'Syntax', 'node2'], ['List', 'cons'], ['Lean', 'Syntax', 'isOfKind'], ['Lean', 'Macro', 'Context'], ['Lean', 'Name', 'mkStr4'], ['Lean', 'TSyntax', 'raw'], ['Lean', 'TSyntax', 'mk'], ['instMonadExceptOfMonadExceptOf'], ['ReaderT', 'instMonadExceptOf'], ['Lean', 'Syntax', 'getArg'], ['Lean', 'Syntax'], ['Lean', 'Macro', 'Exception', 'unsupportedSyntax'], ['EStateM', 'instMonadExceptOfOfBacktrackable'], ['Lean', 'MacroScope'], ['Lean', 'MonadRef', 'mkInfoFromRefPos'], ['ReaderT', 'instApplicativeOfMonad'], ['Lean', 'Name', 'mkStr2'], ['Lean', 'MonadQuotation', 'getMainModule'], ['Lean', 'SyntaxNodeKind'], ['letFun'], ['EStateM', 'nonBacktrackable'], ['MonadExcept', 'throw'], ['Lean', 'SourceInfo'], ['Bool'], ['ReaderT', 'instMonad'], ['Lean', 'Name']] | theorem | Syntax(original=False, range=StringRange(start=2191, stop=2283)) | True | ['Mathlib', 'Probability', 'Notation'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
ProbabilityTheory._aux___unexpand_MeasureTheory_Measure_rnDeriv_1 | import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
open MeasureTheory
open scoped MeasureTheory
| import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
| open MeasureTheory
open scoped MeasureTheory
| scoped[ProbabilityTheory] notation "β" P "/β" Q:100 => MeasureTheory.Measure.rnDeriv P Q := sorry | def _aux___unexpand_MeasureTheory_Measure_rnDeriv_1_extracted : Lean.PrettyPrinter.Unexpander := sorry | [['Lean', 'PrettyPrinter', 'Unexpander']] | scoped[ProbabilityTheory] notation "β" P "/β" Q:100 => MeasureTheory.Measure.rnDeriv P Q | [['Lean', 'withRef'], ['Lean', 'Syntax', 'matchesNull'], ['EStateM'], ['cond'], ['OfNat', 'ofNat'], ['Lean', 'Name', 'mkStr1'], ['Lean', 'Syntax', 'node4'], ['Pure', 'pure'], ['Monad', 'toBind'], ['Eq'], ['ite'], ['Lean', 'TSyntax'], ['EStateM', 'instMonad'], ['Lean', 'MonadQuotation', 'getCurrMacroScope'], ['Bool', 'true'], ['Unit', 'unit'], ['PUnit'], ['instOfNatNat'], ['List', 'nil'], ['Nat'], ['Bind', 'bind'], ['Applicative', 'toPure'], ['instDecidableEqBool'], ['Lean', 'PrettyPrinter', 'instMonadQuotationUnexpandM'], ['Lean', 'Syntax', 'isOfKind'], ['List', 'cons'], ['Lean', 'Name', 'mkStr4'], ['Unit'], ['Lean', 'TSyntax', 'raw'], ['Lean', 'TSyntax', 'mk'], ['Lean', 'MonadQuotation', 'toMonadRef'], ['instMonadExceptOfMonadExceptOf'], ['Lean', 'Syntax', 'atom'], ['ReaderT', 'instMonadExceptOf'], ['Lean', 'Syntax', 'getArg'], ['Lean', 'Syntax'], ['EStateM', 'instMonadExceptOfOfBacktrackable'], ['Lean', 'MacroScope'], ['Lean', 'MonadRef', 'mkInfoFromRefPos'], ['or'], ['Lean', 'Name', 'mkStr2'], ['ReaderT', 'instApplicativeOfMonad'], ['Lean', 'MonadQuotation', 'getMainModule'], ['Bool', 'false'], ['Lean', 'PrettyPrinter', 'UnexpandM'], ['letFun'], ['Lean', 'SyntaxNodeKind'], ['EStateM', 'nonBacktrackable'], ['MonadExcept', 'throw'], ['Lean', 'SourceInfo'], ['Bool'], ['ReaderT', 'instMonad'], ['Lean', 'Name']] | theorem | Syntax(original=False, range=StringRange(start=2191, stop=2283)) | True | ['Mathlib', 'Probability', 'Notation'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
ProbabilityTheory.termβ | import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
open MeasureTheory
open scoped MeasureTheory
| import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
| open MeasureTheory
open scoped MeasureTheory
| scoped[ProbabilityTheory] notation "β" => MeasureTheory.MeasureSpace.volume := sorry | def termβ_extracted : Lean.ParserDescr := sorry | [['Lean', 'ParserDescr']] | scoped[ProbabilityTheory] notation "β" => MeasureTheory.MeasureSpace.volume | [['Lean', 'Name', 'mkStr2'], ['OfNat', 'ofNat'], ['Lean', 'ParserDescr', 'node'], ['instOfNatNat'], ['Nat'], ['Lean', 'ParserDescr', 'symbol']] | theorem | Syntax(original=False, range=StringRange(start=2285, stop=2362)) | True | ['Mathlib', 'Probability', 'Notation'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
ProbabilityTheory._aux___macroRules_ProbabilityTheory_termβ_1 | import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
open MeasureTheory
open scoped MeasureTheory
| import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
| open MeasureTheory
open scoped MeasureTheory
| scoped[ProbabilityTheory] notation "β" => MeasureTheory.MeasureSpace.volume := sorry | def _aux___macroRules_ProbabilityTheory_termβ_1_extracted : Lean.Macro := sorry | [['Lean', 'Macro']] | scoped[ProbabilityTheory] notation "β" => MeasureTheory.MeasureSpace.volume | [['EStateM'], ['OfNat', 'ofNat'], ['Lean', 'Name', 'mkStr3'], ['String', "toSubstring'"], ['Lean', 'MacroM'], ['String'], ['Lean', 'Syntax', 'Preresolved', 'decl'], ['Lean', 'Name', 'mkStr1'], ['Lean', 'Macro', 'instMonadQuotationMacroM'], ['Lean', 'Syntax', 'Preresolved'], ['Lean', 'addMacroScope'], ['Pure', 'pure'], ['Monad', 'toBind'], ['Lean', 'Macro', 'instMonadRefMacroM'], ['Eq'], ['ite'], ['EStateM', 'instMonad'], ['Lean', 'MonadQuotation', 'getCurrMacroScope'], ['Lean', 'Macro', 'State'], ['Bool', 'true'], ['PUnit'], ['Lean', 'Macro', 'Exception'], ['instOfNatNat'], ['Lean', 'Syntax', 'ident'], ['List', 'nil'], ['Bind', 'bind'], ['Nat'], ['Applicative', 'toPure'], ['instDecidableEqBool'], ['List', 'cons'], ['Lean', 'Syntax', 'isOfKind'], ['Lean', 'Macro', 'Context'], ['Lean', 'TSyntax', 'raw'], ['Lean', 'TSyntax', 'mk'], ['instMonadExceptOfMonadExceptOf'], ['ReaderT', 'instMonadExceptOf'], ['Lean', 'Syntax', 'getArg'], ['Lean', 'Syntax'], ['Lean', 'Macro', 'Exception', 'unsupportedSyntax'], ['EStateM', 'instMonadExceptOfOfBacktrackable'], ['Lean', 'MacroScope'], ['Lean', 'MonadRef', 'mkInfoFromRefPos'], ['Lean', 'Name', 'mkStr2'], ['ReaderT', 'instApplicativeOfMonad'], ['Lean', 'MonadQuotation', 'getMainModule'], ['Lean', 'SyntaxNodeKind'], ['letFun'], ['EStateM', 'nonBacktrackable'], ['MonadExcept', 'throw'], ['Lean', 'SourceInfo'], ['ReaderT', 'instMonad'], ['Bool'], ['Lean', 'Name']] | theorem | Syntax(original=False, range=StringRange(start=2285, stop=2362)) | True | ['Mathlib', 'Probability', 'Notation'] | null | leanprover/lean4:v4.11.0
| Mathlib |
|||||
ProbabilityTheory._aux___unexpand_MeasureTheory_MeasureSpace_volume_1 | import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
open MeasureTheory
open scoped MeasureTheory
| import Init
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic
import Mathlib.MeasureTheory.Decomposition.Lebesgue
import Mathlib.Probability.Notation
| open MeasureTheory
open scoped MeasureTheory
| scoped[ProbabilityTheory] notation "β" => MeasureTheory.MeasureSpace.volume := sorry | def _aux___unexpand_MeasureTheory_MeasureSpace_volume_1_extracted : Lean.PrettyPrinter.Unexpander := sorry | [['Lean', 'PrettyPrinter', 'Unexpander']] | scoped[ProbabilityTheory] notation "β" => MeasureTheory.MeasureSpace.volume | [['Lean', 'withRef'], ['EStateM'], ['cond'], ['Lean', 'Name', 'mkStr1'], ['Pure', 'pure'], ['Monad', 'toBind'], ['Lean', 'TSyntax'], ['EStateM', 'instMonad'], ['Lean', 'MonadQuotation', 'getCurrMacroScope'], ['Lean', 'Syntax', 'node1'], ['Unit', 'unit'], ['PUnit'], ['List', 'nil'], ['Bind', 'bind'], ['Applicative', 'toPure'], ['Lean', 'PrettyPrinter', 'instMonadQuotationUnexpandM'], ['List', 'cons'], ['Lean', 'Syntax', 'isOfKind'], ['Unit'], ['Lean', 'TSyntax', 'raw'], ['Lean', 'TSyntax', 'mk'], ['Lean', 'MonadQuotation', 'toMonadRef'], ['instMonadExceptOfMonadExceptOf'], ['Lean', 'Syntax', 'atom'], ['ReaderT', 'instMonadExceptOf'], ['Lean', 'Syntax'], ['EStateM', 'instMonadExceptOfOfBacktrackable'], ['Lean', 'MacroScope'], ['or'], ['Lean', 'MonadRef', 'mkInfoFromRefPos'], ['Lean', 'Name', 'mkStr2'], ['ReaderT', 'instApplicativeOfMonad'], ['Bool', 'false'], ['Lean', 'MonadQuotation', 'getMainModule'], ['Lean', 'SyntaxNodeKind'], ['Lean', 'PrettyPrinter', 'UnexpandM'], ['letFun'], ['EStateM', 'nonBacktrackable'], ['MonadExcept', 'throw'], ['Lean', 'SourceInfo'], ['ReaderT', 'instMonad'], ['Lean', 'Name']] | theorem | Syntax(original=False, range=StringRange(start=2285, stop=2362)) | True | ['Mathlib', 'Probability', 'Notation'] | null | leanprover/lean4:v4.11.0
| Mathlib |
End of preview. Expand
in Dataset Viewer.
README.md exists but content is empty.
- Downloads last month
- 31