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 Data Studio
README.md exists but content is empty.
- Downloads last month
- 14