name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Matroid.IsBasis.isBase_of_spanning | Mathlib.Combinatorics.Matroid.Closure | ∀ {α : Type u_2} {M : Matroid α} {X I : Set α}, M.IsBasis I X → M.Spanning X → M.IsBase I | true |
Prod.instCoalgebra._proof_7 | Mathlib.RingTheory.Coalgebra.Basic | ∀ (R : Type u_1) (A : Type u_2) (B : Type u_3) [inst : CommSemiring R] [inst_1 : AddCommMonoid A]
[inst_2 : AddCommMonoid B] [inst_3 : Module R A] [inst_4 : Module R B] [inst_5 : Coalgebra R A]
[inst_6 : Coalgebra R B],
LinearMap.rTensor (A × B) CoalgebraStruct.counit ∘ₗ CoalgebraStruct.comul = (TensorProduct.mk R R (A × B)) 1 | false |
LocallyConstant.coe_inj._simp_1 | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] {f g : LocallyConstant X Y}, (⇑f = ⇑g) = (f = g) | false |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.ediv_mul_of_nonneg._proof_1_1 | Init.Data.Int.DivMod.Lemmas | ∀ {x y z : ℤ}, x / y / z = x / (y * z) → ¬x / (y * z) = x / y / z → False | false |
AlgebraicGeometry.IsAffineOpen.arrowStalkMapIso._proof_8 | Mathlib.AlgebraicGeometry.AffineScheme | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) {x : ↥X} (U : Y.Opens) (hU : AlgebraicGeometry.IsAffineOpen U)
(V : X.Opens) (hV : AlgebraicGeometry.IsAffineOpen V) (hVU : V ≤ (TopologicalSpace.Opens.map f.base).obj U)
(hx : x ∈ V) (this : IsLocalization.AtPrime (↑(Y.presheaf.stalk ↑⟨f x, ⋯⟩)) (hU.primeIdealOf ⟨f x, ⋯⟩).asIdeal)
(this_1 : IsLocalization.AtPrime (↑(X.presheaf.stalk ↑⟨x, hx⟩)) (hV.primeIdealOf ⟨x, hx⟩).asIdeal),
CategoryTheory.CategoryStruct.comp
(IsLocalization.algEquiv (hU.primeIdealOf ⟨f x, ⋯⟩).asIdeal.primeCompl (↑(Y.presheaf.stalk (f x)))
(Localization.AtPrime (hU.primeIdealOf ⟨f x, ⋯⟩).asIdeal)).toRingEquiv.toCommRingCatIso.hom
(CommRingCat.ofHom
(Localization.localRingHom (hU.primeIdealOf ⟨f x, ⋯⟩).asIdeal (hV.primeIdealOf ⟨x, hx⟩).asIdeal
(CommRingCat.Hom.hom (AlgebraicGeometry.Scheme.Hom.appLE f U V hVU)) ⋯)) =
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.Hom.stalkMap f x)
(IsLocalization.algEquiv (hV.primeIdealOf ⟨x, hx⟩).asIdeal.primeCompl (↑(X.presheaf.stalk x))
(Localization.AtPrime (hV.primeIdealOf ⟨x, hx⟩).asIdeal)).toRingEquiv.toCommRingCatIso.hom | false |
Lean.Lsp.CodeActionClientCapabilities.dataSupport?._default | Lean.Data.Lsp.CodeActions | Option Bool | false |
_private.Mathlib.Algebra.Homology.BifunctorAssociator.0.HomologicalComplex.instHasMapProdObjGradedObjectFunctorMapBifunctorMapBifunctorMapObjπX._proof_1 | Mathlib.Algebra.Homology.BifunctorAssociator | ∀ {C₁ : Type u_11} {C₂ : Type u_13} {C₁₂ : Type u_9} {C₃ : Type u_7} {C₄ : Type u_5}
[inst : CategoryTheory.Category.{u_10, u_11} C₁] [inst_1 : CategoryTheory.Category.{u_12, u_13} C₂]
[inst_2 : CategoryTheory.Category.{u_6, u_7} C₃] [inst_3 : CategoryTheory.Category.{u_4, u_5} C₄]
[inst_4 : CategoryTheory.Category.{u_8, u_9} C₁₂] [inst_5 : CategoryTheory.Limits.HasZeroMorphisms C₁]
[inst_6 : CategoryTheory.Limits.HasZeroMorphisms C₂] [inst_7 : CategoryTheory.Limits.HasZeroMorphisms C₃]
[inst_8 : CategoryTheory.Preadditive C₁₂] [inst_9 : CategoryTheory.Preadditive C₄]
{F₁₂ : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₁₂)}
{G : CategoryTheory.Functor C₁₂ (CategoryTheory.Functor C₃ C₄)} [inst_10 : F₁₂.PreservesZeroMorphisms]
[inst_11 : ∀ (X₁ : C₁), (F₁₂.obj X₁).PreservesZeroMorphisms] [inst_12 : G.Additive]
[inst_13 : ∀ (X₁₂ : C₁₂), (G.obj X₁₂).PreservesZeroMorphisms] {ι₁ : Type u_14} {ι₂ : Type u_15} {ι₃ : Type u_2}
{ι₁₂ : Type u_1} {ι₄ : Type u_3} {c₁ : ComplexShape ι₁} {c₂ : ComplexShape ι₂} {c₃ : ComplexShape ι₃}
(K₁ : HomologicalComplex C₁ c₁) (K₂ : HomologicalComplex C₂ c₂) (K₃ : HomologicalComplex C₃ c₃)
(c₁₂ : ComplexShape ι₁₂) (c₄ : ComplexShape ι₄) [inst_14 : TotalComplexShape c₁ c₂ c₁₂]
[inst_15 : TotalComplexShape c₁₂ c₃ c₄] [inst_16 : K₁.HasMapBifunctor K₂ F₁₂ c₁₂] [inst_17 : DecidableEq ι₁₂]
[(K₁.mapBifunctor K₂ F₁₂ c₁₂).HasMapBifunctor K₃ G c₄],
(((CategoryTheory.GradedObject.mapBifunctor G ι₁₂ ι₃).obj
(CategoryTheory.GradedObject.mapBifunctorMapObj F₁₂ (c₁.π c₂ c₁₂) K₁.X K₂.X)).obj
K₃.X).HasMap
(c₁₂.π c₃ c₄) | false |
SimpleGraph.Subgraph.sup_adj | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} {G₁ G₂ : G.Subgraph} {a b : V}, (G₁ ⊔ G₂).Adj a b ↔ G₁.Adj a b ∨ G₂.Adj a b | true |
_private.Mathlib.Analysis.LocallyConvex.WeakDual.0.LinearMap.mem_span_iff_continuous._simp_1_1 | Mathlib.Analysis.LocallyConvex.WeakDual | ∀ {ι : Type u_4} {𝕜 : Type u_5} {E : Type u_6} [Finite ι] [inst : Field 𝕜] [t𝕜 : TopologicalSpace 𝕜]
[IsTopologicalRing 𝕜] [inst_2 : AddCommGroup E] [inst_3 : Module 𝕜 E] [T0Space 𝕜] {f : ι → E →ₗ[𝕜] 𝕜} (φ : E →ₗ[𝕜] 𝕜),
Continuous ⇑φ = (φ ∈ Submodule.span 𝕜 (Set.range f)) | false |
CategoryTheory.ObjectProperty.LimitOfShape.ofIso | Mathlib.CategoryTheory.ObjectProperty.LimitsOfShape | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{P : CategoryTheory.ObjectProperty C} →
{J : Type u'} →
[inst_1 : CategoryTheory.Category.{v', u'} J] →
{X : C} → P.LimitOfShape J X → {Y : C} → (X ≅ Y) → P.LimitOfShape J Y | true |
Std.TreeMap.Equiv.getEntryGED_eq | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α}
{fallback : α × β}, t₁.Equiv t₂ → t₁.getEntryGED k fallback = t₂.getEntryGED k fallback | true |
CategoryTheory.Comma.mapLeftComp | Mathlib.CategoryTheory.Comma.Basic | {A : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
{B : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
{T : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} T] →
(R : CategoryTheory.Functor B T) →
{L₁ L₂ L₃ : CategoryTheory.Functor A T} →
(l : L₁ ⟶ L₂) →
(l' : L₂ ⟶ L₃) →
CategoryTheory.Comma.mapLeft R (CategoryTheory.CategoryStruct.comp l l') ≅
(CategoryTheory.Comma.mapLeft R l').comp (CategoryTheory.Comma.mapLeft R l) | true |
CategoryTheory.GrothendieckTopology.pullbackComp | Mathlib.CategoryTheory.Sites.Grothendieck | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(J : CategoryTheory.GrothendieckTopology C) →
{X Y Z : C} →
(f : X ⟶ Y) →
(g : Y ⟶ Z) → J.pullback (CategoryTheory.CategoryStruct.comp f g) ≅ (J.pullback g).comp (J.pullback f) | true |
Multiset.Rel.trans | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} (r : α → α → Prop) [IsTrans α r] {s t u : Multiset α},
Multiset.Rel r s t → Multiset.Rel r t u → Multiset.Rel r s u | true |
Equiv.Perm.cycleFactorsFinset_eq_singleton_self_iff._simp_1 | Mathlib.GroupTheory.Perm.Cycle.Factors | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Fintype α] {f : Equiv.Perm α},
(f.cycleFactorsFinset = {f}) = f.IsCycle | false |
_private.Lean.Meta.Tactic.FunInd.0.Lean.Tactic.FunInd.deriveInductionStructural.match_9 | Lean.Meta.Tactic.FunInd | (motive : Option (Lean.Elab.Structural.RecArgInfo × Subarray Lean.Elab.Structural.RecArgInfo) → Sort u_1) →
(x : Option (Lean.Elab.Structural.RecArgInfo × Subarray Lean.Elab.Structural.RecArgInfo)) →
(Unit → motive none) →
((recArgInfo : Lean.Elab.Structural.RecArgInfo) →
(s' : Subarray Lean.Elab.Structural.RecArgInfo) → motive (some (recArgInfo, s'))) →
motive x | false |
List.replicate_sublist_replicate._simp_1 | Init.Data.List.Sublist | ∀ {α : Type u_1} {m n : ℕ} (a : α), (List.replicate m a).Sublist (List.replicate n a) = (m ≤ n) | false |
_private.Mathlib.Data.Multiset.Fintype.0.Multiset.map_fst_le_of_subset_toEnumFinset._simp_1_4 | Mathlib.Data.Multiset.Fintype | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) | false |
CategoryTheory.Limits.WalkingParallelFamily.Hom.ctorElimType | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | {J : Type w} →
{motive :
(a a_1 : CategoryTheory.Limits.WalkingParallelFamily J) →
CategoryTheory.Limits.WalkingParallelFamily.Hom J a a_1 → Sort u} →
ℕ → Sort (max 1 (imax (w + 1) u)) | false |
Lean.Doc.DocHighlight.option.noConfusion | Lean.Elab.DocString.Builtin | {P : Sort u} →
{name declName name' declName' : Lean.Name} →
Lean.Doc.DocHighlight.option name declName = Lean.Doc.DocHighlight.option name' declName' →
(name = name' → declName = declName' → P) → P | false |
Std.Tactic.BVDecide.BVExpr.bitblast.TwoPowShiftTarget.mk | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{w : ℕ} →
(n : ℕ) → aig.RefVec w → aig.RefVec n → ℕ → Std.Tactic.BVDecide.BVExpr.bitblast.TwoPowShiftTarget aig w | true |
MeasureTheory.FiniteMeasure.eq_of_forall_apply_eq | Mathlib.MeasureTheory.Measure.FiniteMeasure | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] (μ ν : MeasureTheory.FiniteMeasure Ω),
(∀ (s : Set Ω), MeasurableSet s → μ s = ν s) → μ = ν | true |
NumberField.InfinitePlace.orbitRelEquiv._proof_2 | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | ∀ {k : Type u_2} [inst : Field k] {K : Type u_1} [inst_1 : Field K] [inst_2 : Algebra k K] [inst_3 : IsGalois k K],
Function.Injective (Quotient.lift (fun x => x.comap (algebraMap k K)) ⋯) ∧
Function.Surjective (Quotient.lift (fun x => x.comap (algebraMap k K)) ⋯) | false |
Fin.castLE.eq_1 | Mathlib.Data.Fin.Tuple.Take | ∀ {n m : ℕ} (h : n ≤ m) (i : Fin n), Fin.castLE h i = ⟨↑i, ⋯⟩ | true |
Dilation.edist_eq' | Mathlib.Topology.MetricSpace.Dilation | ∀ {α : Type u_1} {β : Type u_2} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] (self : α →ᵈ β),
∃ r, r ≠ 0 ∧ ∀ (x y : α), edist (self.toFun x) (self.toFun y) = ↑r * edist x y | true |
instHashableFin | Init.Data.Hashable | {n : ℕ} → Hashable (Fin n) | true |
ArithmeticFunction.one_smul' | Mathlib.NumberTheory.ArithmeticFunction.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(b : ArithmeticFunction M), 1 • b = b | true |
DFinsupp.addZeroClass._proof_1 | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u_1} {β : ι → Type u_2} [inst : (i : ι) → AddZeroClass (β i)], Function.Injective fun f => ⇑f | false |
_private.Mathlib.Computability.TuringMachine.ToPartrec.0.Turing.PartrecToTM2.trStmts₁_trans._simp_1_10 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a b : α}, (a ∈ insert b s) = (a = b ∨ a ∈ s) | false |
Option.getD_eq_iff | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {o : Option α} {a b : α}, o.getD a = b ↔ o = some b ∨ o = none ∧ a = b | true |
_private.Init.Data.Vector.OfFn.0.Vector.ofFnM_go_succ._proof_7 | Init.Data.Vector.OfFn | ∀ {α : Type u_1} {i : ℕ} {xs : Array α} {n : ℕ},
autoParam (i ≤ n) Vector.ofFnM_go_succ._auto_5✝ → ∀ {h : xs.size = i}, ¬i ≤ n + 1 → False | false |
Matrix.specialUnitaryGroup.coe_star | Mathlib.LinearAlgebra.UnitaryGroup | ∀ {n : Type u} [inst : DecidableEq n] [inst_1 : Fintype n] {α : Type v} [inst_2 : CommRing α] [inst_3 : StarRing α]
(A : ↥(Matrix.specialUnitaryGroup n α)), ↑(star A) = star ↑A | true |
Algebra.isAlgebraic_adjoin_iff | Mathlib.RingTheory.Algebraic.Integral | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] [IsDomain R]
{s : Set S}, (Algebra.adjoin R s).IsAlgebraic ↔ ∀ x ∈ s, IsAlgebraic R x | true |
_private.Mathlib.GroupTheory.QuotientGroup.Defs.0.QuotientGroup.mk'_eq_mk'._simp_1_1 | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_3} [inst : Group G] {a b c : G}, (b * a = c) = (a = b⁻¹ * c) | false |
PartitionOfUnity.mem_finsupport | Mathlib.Topology.PartitionOfUnity | ∀ {ι : Type u} {X : Type v} [inst : TopologicalSpace X] {s : Set X} (ρ : PartitionOfUnity ι X s) (x₀ : X) {i : ι},
i ∈ ρ.finsupport x₀ ↔ i ∈ Function.support fun i => (ρ i) x₀ | true |
WittVector.IsocrystalHom._sizeOf_inst | Mathlib.RingTheory.WittVector.Isocrystal | (p : ℕ) →
{inst : Fact (Nat.Prime p)} →
(k : Type u_1) →
{inst_1 : CommRing k} →
{inst_2 : CharP k p} →
{inst_3 : PerfectRing k p} →
(V : Type u_2) →
{inst_4 : AddCommGroup V} →
{inst_5 : WittVector.Isocrystal p k V} →
(V₂ : Type u_3) →
{inst_6 : AddCommGroup V₂} →
{inst_7 : WittVector.Isocrystal p k V₂} →
[SizeOf k] → [SizeOf V] → [SizeOf V₂] → SizeOf (WittVector.IsocrystalHom p k V V₂) | false |
UInt64.ofFin_bitVecToFin | Init.Data.UInt.Lemmas | ∀ (n : BitVec 64), UInt64.ofFin n.toFin = { toBitVec := n } | true |
_private.Init.Grind.Ordered.Ring.0.Lean.Grind.OrderedRing.pos_intCast_of_pos._proof_1_1 | Init.Grind.Ordered.Ring | ∀ (a : ℕ), 0 < Int.negSucc a → False | false |
AlgebraicGeometry.IsAffineOpen.isLocalization_stalk | Mathlib.AlgebraicGeometry.AffineScheme | ∀ {X : AlgebraicGeometry.Scheme} {U : X.Opens} (hU : AlgebraicGeometry.IsAffineOpen U) (x : ↥U),
IsLocalization.AtPrime (↑(X.presheaf.stalk ↑x)) (hU.primeIdealOf x).asIdeal | true |
List.lookmap_congr | Mathlib.Data.List.Lookmap | ∀ {α : Type u_1} {f g : α → Option α} {l : List α}, (∀ a ∈ l, f a = g a) → List.lookmap f l = List.lookmap g l | true |
_aux_Mathlib_Analysis_Normed_Affine_Isometry___unexpand_AffineIsometryEquiv_1 | Mathlib.Analysis.Normed.Affine.Isometry | Lean.PrettyPrinter.Unexpander | false |
_private.Mathlib.RingTheory.Polynomial.Basic.0.Polynomial.coeff_prod_mem_ideal_pow_tsub._proof_1_3 | Mathlib.RingTheory.Polynomial.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {ι : Type u_2} (f : ι → Polynomial R) (I : Ideal R) (n : ι → ℕ) (a : ι)
(s : Finset ι),
((∀ i ∈ s, ∀ (k : ℕ), (f i).coeff k ∈ I ^ (n i - k)) → ∀ (k : ℕ), (s.prod f).coeff k ∈ I ^ (s.sum n - k)) →
(∀ i ∈ insert a s, ∀ (k : ℕ), (f i).coeff k ∈ I ^ (n i - k)) →
∀ (i j : ℕ), (∏ x ∈ s, f x).coeff (i, j).2 ∈ I ^ (∑ x ∈ s, n x - j) | false |
List.mem_eraseDups._simp_1 | Init.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a : α} {l : List α}, (a ∈ l.eraseDups) = (a ∈ l) | false |
Lean.Grind.Linarith.Poly.denoteN.match_1 | Init.Grind.Module.NatModuleNorm | (motive : Lean.Grind.Linarith.Poly → Sort u_1) →
(p : Lean.Grind.Linarith.Poly) →
(Unit → motive Lean.Grind.Linarith.Poly.nil) →
((k : ℤ) →
(v : Lean.Grind.Linarith.Var) →
(p : Lean.Grind.Linarith.Poly) → motive (Lean.Grind.Linarith.Poly.add k v p)) →
motive p | false |
CategoryTheory.Mon.mkIso_inv_hom | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{M N : CategoryTheory.Mon C} (e : M.X ≅ N.X)
(one_f :
autoParam (CategoryTheory.CategoryStruct.comp CategoryTheory.MonObj.one e.hom = CategoryTheory.MonObj.one)
CategoryTheory.Mon.mkIso._auto_1)
(mul_f :
autoParam
(CategoryTheory.CategoryStruct.comp CategoryTheory.MonObj.mul e.hom =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.tensorHom e.hom e.hom)
CategoryTheory.MonObj.mul)
CategoryTheory.Mon.mkIso._auto_3),
(CategoryTheory.Mon.mkIso e one_f mul_f).inv.hom = e.inv | true |
Module.End.smulLeft._proof_1 | Mathlib.Algebra.Module.LinearMap.End | ∀ {R : Type u_2} {M : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
∀ α ∈ Set.center R, ∀ (β : R) (x : M), α • β • x = (RingHom.id R) β • α • x | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.clzAuxRec_eq_iff_of_getLsbD_false._proof_1_5 | Init.Data.BitVec.Lemmas | ∀ (w : ℕ), (1 < 2 → w + 1 < 2 ^ (w + 1)) → ∀ (n : ℕ), ¬w - (n + 1) < 2 ^ (w + 1) → False | false |
_private.Lean.Meta.Tactic.Grind.EMatch.0.Lean.Meta.Grind.EMatch.processOffset.match_1 | Lean.Meta.Tactic.Grind.EMatch | (motive : Option ℕ → Sort u_1) →
(__do_lift : Option ℕ) → ((k' : ℕ) → motive (some k')) → ((x : Option ℕ) → motive x) → motive __do_lift | false |
IsCoveringMap.liftPath_const | Mathlib.Topology.Homotopy.Lifting | ∀ {E : Type u_1} {X : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] {p : E → X}
(cov : IsCoveringMap p) {e : E} {x : X} (hpe : x = p e),
cov.liftPath (ContinuousMap.const (↑unitInterval) x) e hpe = ContinuousMap.const (↑unitInterval) e | true |
CategoryTheory.leftAdjointOfStructuredArrowInitials._proof_1 | Mathlib.CategoryTheory.Adjunction.Comma | ∀ {C : Type u_4} {D : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (G : CategoryTheory.Functor D C)
[inst_2 : ∀ (A : C), CategoryTheory.Limits.HasInitial (CategoryTheory.StructuredArrow A G)] (x : C) (x_1 Y' : D)
(g : x_1 ⟶ Y') (h : (⊥_ CategoryTheory.StructuredArrow x G).right ⟶ x_1),
(CategoryTheory.leftAdjointOfStructuredArrowInitialsAux G x Y') (CategoryTheory.CategoryStruct.comp h g) =
CategoryTheory.CategoryStruct.comp ((CategoryTheory.leftAdjointOfStructuredArrowInitialsAux G x x_1) h) (G.map g) | false |
String.Slice.PosIterator.recOn | Init.Data.String.Iterate | {s : String.Slice} →
{motive : s.PosIterator → Sort u} →
(t : s.PosIterator) → ((currPos : s.Pos) → motive { currPos := currPos }) → motive t | false |
GradedRing.projZeroRingHom' | Mathlib.RingTheory.GradedAlgebra.Basic | {ι : Type u_1} →
{A : Type u_3} →
{σ : Type u_4} →
[inst : Semiring A] →
[inst_1 : DecidableEq ι] →
[inst_2 : AddCommMonoid ι] →
[inst_3 : PartialOrder ι] →
[CanonicallyOrderedAdd ι] →
[inst_5 : SetLike σ A] →
[inst_6 : AddSubmonoidClass σ A] → (𝒜 : ι → σ) → [inst_7 : GradedRing 𝒜] → A →+* ↥(𝒜 0) | true |
_private.Mathlib.Algebra.Polynomial.RuleOfSigns.0.Polynomial.exists_cons_of_leadingCoeff_pos._proof_1_5 | Mathlib.Algebra.Polynomial.RuleOfSigns | ∀ {R : Type u_1} [inst : Ring R] {P : Polynomial R} (η : R),
P.eraseLead.natDegree + 1 = P.natDegree →
∀ (d : ℕ),
P.natDegree = 0 + d + 1 →
((Polynomial.X - Polynomial.C η) * P).natDegree = P.natDegree + 1 →
((Polynomial.X - Polynomial.C η) * P).nextCoeff = 0 →
Polynomial.C η * (Polynomial.monomial P.natDegree) P.leadingCoeff =
(Polynomial.monomial P.natDegree) P.nextCoeff | false |
SeminormedGroup.ofMulDist._proof_2 | Mathlib.Analysis.Normed.Group.Defs | ∀ {E : Type u_1} [inst : Norm E] [inst_1 : Group E] [inst_2 : PseudoMetricSpace E],
(∀ (x : E), ‖x‖ = dist 1 x) → (∀ (x y z : E), dist x y ≤ dist (z * x) (z * y)) → ∀ (x y : E), dist x y = ‖x⁻¹ * y‖ | false |
Mathlib.Tactic.Superscript.scriptFnNoAntiquot | Mathlib.Util.Superscript | Mathlib.Tactic.Superscript.Mapping → String → Lean.Parser.ParserFn → optParam Bool true → Lean.Parser.ParserFn | true |
PreTilt.valAux_one | Mathlib.RingTheory.Perfection | ∀ {K : Type u₁} [inst : Field K] {v : Valuation K NNReal} {O : Type u₂} [inst_1 : CommRing O] [inst_2 : Algebra O K],
v.Integers O → ∀ {p : ℕ} [inst_3 : Fact (Nat.Prime p)] [inst_4 : Fact ¬IsUnit ↑p], PreTilt.valAux K v O p 1 = 1 | true |
Fintype.decidableForallFintype._proof_1 | Mathlib.Data.Fintype.Defs | ∀ {α : Type u_1} {p : α → Prop} [inst : Fintype α], (∀ a ∈ Finset.univ, p a) ↔ ∀ (a : α), p a | false |
Set.coe_singletonAddMonoidHom | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : AddZeroClass α], ⇑Set.singletonAddMonoidHom = singleton | true |
CategoryTheory.IsRegularMono.fac_assoc | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y W : C} (f : X ⟶ Y)
[inst_1 : CategoryTheory.IsRegularMono f] (k : W ⟶ Y)
(h :
CategoryTheory.CategoryStruct.comp k (CategoryTheory.IsRegularMono.left f) =
CategoryTheory.CategoryStruct.comp k (CategoryTheory.IsRegularMono.right f))
{Z : C} (h_1 : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.IsRegularMono.lift f k h)
(CategoryTheory.CategoryStruct.comp f h_1) =
CategoryTheory.CategoryStruct.comp k h_1 | true |
_private.Init.Data.List.Lemmas.0.List.flatMap_eq_nil_iff._simp_1_2 | Init.Data.List.Lemmas | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | false |
AlgEquiv.lift_trdeg_eq | Mathlib.RingTheory.AlgebraicIndependent.Basic | ∀ {R : Type u_2} {A : Type v} {A' : Type v'} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : CommRing A']
[inst_3 : Algebra R A] [inst_4 : Algebra R A'] (e : A ≃ₐ[R] A'),
Cardinal.lift.{v', v} (Algebra.trdeg R A) = Cardinal.lift.{v, v'} (Algebra.trdeg R A') | true |
_private.Mathlib.GroupTheory.Perm.Support.0.Equiv.Perm.support_inv._simp_1_2 | Mathlib.GroupTheory.Perm.Support | ∀ {a b : Prop}, (¬a ↔ ¬b) = (a ↔ b) | false |
instDecidableEqSum.decEq | Init.Core | {α : Type u_1} → {β : Type u_2} → [DecidableEq α] → [DecidableEq β] → (x x_1 : α ⊕ β) → Decidable (x = x_1) | true |
_private.Mathlib.Combinatorics.SimpleGraph.Basic.0.SimpleGraph.mk'._simp_4 | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {a b : Bool}, (a = true ↔ b = true) = (a = b) | false |
Vector.map_inj_left | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {n : ℕ} {xs : Vector α n} {f g : α → β},
Vector.map f xs = Vector.map g xs ↔ ∀ a ∈ xs, f a = g a | true |
commMonTypeEquivalenceCommMon._proof_1 | Mathlib.CategoryTheory.Monoidal.Internal.Types.Basic | ∀ {X Y : CommMonCat} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
((CommMonTypeEquivalenceCommMon.inverse.comp CommMonTypeEquivalenceCommMon.functor).map f)
((fun A =>
(let __src := Equiv.refl (CommMonTypeEquivalenceCommMon.inverse.obj A).X;
{ toEquiv := __src, map_mul' := ⋯ }).toCommMonCatIso)
Y).hom =
CategoryTheory.CategoryStruct.comp
((fun A =>
(let __src := Equiv.refl (CommMonTypeEquivalenceCommMon.inverse.obj A).X;
{ toEquiv := __src, map_mul' := ⋯ }).toCommMonCatIso)
X).hom
((CategoryTheory.Functor.id CommMonCat).map f) | false |
_private.Init.Data.Array.BasicAux.0.Array.mapM'.go._unary.eq_def | Init.Data.Array.BasicAux | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [inst : Monad m] (f : α → m β) (as : Array α)
(_x : (i : ℕ) ×' (_ : { bs // bs.size = i }) ×' i ≤ as.size),
Array.mapM'.go._unary✝ f as _x =
PSigma.casesOn _x fun i acc =>
PSigma.casesOn acc fun acc hle =>
if h : i = as.size then pure (h ▸ acc)
else
have hlt := ⋯;
do
let b ← f as[i]
Array.mapM'.go._unary✝¹ f as ⟨i + 1, ⟨⟨(↑acc).push b, ⋯⟩, hlt⟩⟩ | false |
AddAction.vadd_zsmul_movedBy_eq_of_addCommute | Mathlib.GroupTheory.GroupAction.FixedPoints | ∀ {α : Type u_1} {G : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G α] {g h : G},
AddCommute g h → ∀ (j : ℤ), j • h +ᵥ (AddAction.fixedBy α g)ᶜ = (AddAction.fixedBy α g)ᶜ | true |
IsLocalMax.add | Mathlib.Topology.Order.LocalExtr | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : AddCommMonoid β] [inst_2 : PartialOrder β]
[IsOrderedAddMonoid β] {f g : α → β} {a : α}, IsLocalMax f a → IsLocalMax g a → IsLocalMax (fun x => f x + g x) a | true |
_private.Mathlib.Algebra.Order.SuccPred.WithBot.0.WithBot.one_le_iff_pos._simp_1_1 | Mathlib.Algebra.Order.SuccPred.WithBot | ∀ {α : Type u_1} {x : α} [inst : PartialOrder α] [inst_1 : AddMonoidWithOne α] [ZeroLEOneClass α] [NeZero 1]
[SuccAddOrder α], (1 ≤ x) = (0 < x) | false |
List.filterMap_append | Init.Data.List.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {l l' : List α} {f : α → Option β},
List.filterMap f (l ++ l') = List.filterMap f l ++ List.filterMap f l' | true |
Std.HashMap.Raw.getKeyD_insert_self | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], m.WF → ∀ {k fallback : α} {v : β}, (m.insert k v).getKeyD k fallback = k | true |
basisOfPiSpaceOfLinearIndependent | Mathlib.LinearAlgebra.FiniteDimensional.Lemmas | {K : Type u} →
[inst : DivisionRing K] →
{ι : Type u_1} →
[Fintype ι] → [Decidable (Nonempty ι)] → {b : ι → ι → K} → LinearIndependent K b → Module.Basis ι K (ι → K) | true |
_private.Mathlib.Algebra.Module.Injective.0.Module.Baer.extension_property_addMonoidHom.match_1_1 | Mathlib.Algebra.Module.Injective | ∀ {Q : Type u_1} [inst : AddCommGroup Q] {M : Type u_3} {N : Type u_2} [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] (f : M →+ N) (g : M →+ Q) (motive : (∃ h, h ∘ₗ f.toIntLinearMap = g.toIntLinearMap) → Prop)
(x : ∃ h, h ∘ₗ f.toIntLinearMap = g.toIntLinearMap),
(∀ (g' : N →ₗ[ℤ] Q) (hg' : g' ∘ₗ f.toIntLinearMap = g.toIntLinearMap), motive ⋯) → motive x | false |
CommRingCat.prodFanIsLimit._proof_3 | Mathlib.Algebra.Category.Ring.Constructions | ∀ (A B : CommRingCat) (s : CategoryTheory.Limits.Cone (CategoryTheory.Limits.pair A B)) (m : s.pt ⟶ (A.prodFan B).pt),
(∀ (j : CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair),
CategoryTheory.CategoryStruct.comp m ((A.prodFan B).π.app j) = s.π.app j) →
m =
CommRingCat.ofHom
((CommRingCat.Hom.hom (s.π.app { as := CategoryTheory.Limits.WalkingPair.left })).prod
(CommRingCat.Hom.hom (s.π.app { as := CategoryTheory.Limits.WalkingPair.right }))) | false |
Nat.Primes.coe_pnat_inj | Mathlib.Data.PNat.Prime | ∀ (p q : Nat.Primes), ↑p = ↑q ↔ p = q | true |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.Slope.0.MonotoneOn.intervalIntegral_slope_le._simp_1_24 | Mathlib.MeasureTheory.Integral.IntervalIntegral.Slope | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False | false |
Lean.Meta.Grind.Arith.CommRing.State.ncSemirings | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | Lean.Meta.Grind.Arith.CommRing.State → Array Lean.Meta.Grind.Arith.CommRing.Semiring | true |
Lists.Equiv.symm | Mathlib.SetTheory.Lists | ∀ {α : Type u_1} {l₁ l₂ : Lists α}, l₁.Equiv l₂ → l₂.Equiv l₁ | true |
fderivWithin_fun_sub | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f g : E → F}
{x : E} {s : Set E},
UniqueDiffWithinAt 𝕜 s x →
DifferentiableWithinAt 𝕜 f s x →
DifferentiableWithinAt 𝕜 g s x →
fderivWithin 𝕜 (fun y => f y - g y) s x = fderivWithin 𝕜 f s x - fderivWithin 𝕜 g s x | true |
ContinuousMulEquiv.coe_trans | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ {M : Type u_1} {N : Type u_2} [inst : TopologicalSpace M] [inst_1 : TopologicalSpace N] [inst_2 : Mul M]
[inst_3 : Mul N] {L : Type u_3} [inst_4 : Mul L] [inst_5 : TopologicalSpace L] (e₁ : M ≃ₜ* N) (e₂ : N ≃ₜ* L),
⇑(e₁.trans e₂) = ⇑e₂ ∘ ⇑e₁ | true |
PiTensorProduct.lift_reindex | Mathlib.LinearAlgebra.PiTensorProduct | ∀ {ι : Type u_1} {ι₂ : Type u_2} {R : Type u_4} [inst : CommSemiring R] {s : ι → Type u_7}
[inst_1 : (i : ι) → AddCommMonoid (s i)] [inst_2 : (i : ι) → Module R (s i)] {E : Type u_9} [inst_3 : AddCommMonoid E]
[inst_4 : Module R E] (e : ι ≃ ι₂) (φ : MultilinearMap R (fun i => s (e.symm i)) E)
(x : PiTensorProduct R fun i => s i),
(PiTensorProduct.lift φ) ((PiTensorProduct.reindex R s e) x) =
(PiTensorProduct.lift ((MultilinearMap.domDomCongrLinearEquiv' R R s E e).symm φ)) x | true |
Lean.Compiler.LCNF.CodeDecl.casesOn | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
{motive : Lean.Compiler.LCNF.CodeDecl pu → Sort u} →
(t : Lean.Compiler.LCNF.CodeDecl pu) →
((decl : Lean.Compiler.LCNF.LetDecl pu) → motive (Lean.Compiler.LCNF.CodeDecl.let decl)) →
((decl : Lean.Compiler.LCNF.FunDecl pu) →
(h : pu = Lean.Compiler.LCNF.Purity.pure) → motive (Lean.Compiler.LCNF.CodeDecl.fun decl h)) →
((decl : Lean.Compiler.LCNF.FunDecl pu) → motive (Lean.Compiler.LCNF.CodeDecl.jp decl)) →
((fvarId : Lean.FVarId) →
(i : ℕ) →
(y : Lean.FVarId) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) →
motive (Lean.Compiler.LCNF.CodeDecl.uset fvarId i y h)) →
((fvarId : Lean.FVarId) →
(i offset : ℕ) →
(y : Lean.FVarId) →
(ty : Lean.Expr) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) →
motive (Lean.Compiler.LCNF.CodeDecl.sset fvarId i offset y ty h)) →
((fvarId : Lean.FVarId) →
(n : ℕ) →
(check persistent : Bool) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) →
motive (Lean.Compiler.LCNF.CodeDecl.inc fvarId n check persistent h)) →
((fvarId : Lean.FVarId) →
(n : ℕ) →
(check persistent : Bool) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) →
motive (Lean.Compiler.LCNF.CodeDecl.dec fvarId n check persistent h)) →
motive t | false |
Lean.Meta.Grind.Filter.and | Lean.Meta.Tactic.Grind.Filter | Lean.Meta.Grind.Filter → Lean.Meta.Grind.Filter → Lean.Meta.Grind.Filter | true |
Tactic.ComputeAsymptotics.WellFormedBasis.tendsto_atTop | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Basis | ∀ {basis : Tactic.ComputeAsymptotics.Basis},
Tactic.ComputeAsymptotics.WellFormedBasis basis →
∀ {f : ℝ → ℝ}, f ∈ basis → Filter.Tendsto f Filter.atTop Filter.atTop | true |
CategoryTheory.Functor.representableByUliftFunctorEquiv._proof_3 | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {F : CategoryTheory.Functor Cᵒᵖ (Type u_2)} {X : C},
Function.RightInverse (fun R => { homEquiv := fun {Y} => R.homEquiv.trans Equiv.ulift.symm, homEquiv_comp := ⋯ })
fun R => { homEquiv := fun {Y} => R.homEquiv.trans Equiv.ulift, homEquiv_comp := ⋯ } | false |
Std.Internal.List.insertListIfNew._unsafe_rec | Std.Data.Internal.List.Associative | {α : Type u} → {β : α → Type v} → [BEq α] → List ((a : α) × β a) → List ((a : α) × β a) → List ((a : α) × β a) | false |
_private.Mathlib.MeasureTheory.Measure.LevyProkhorovMetric.0.MeasureTheory.levyProkhorovEDist_le_of_forall._simp_1_2 | Mathlib.MeasureTheory.Measure.LevyProkhorovMetric | ∀ {G : Type u_1} [inst : AddSemigroup G] (a b c : G), a + (b + c) = a + b + c | false |
Std.DTreeMap.Internal.Unit.RocSliceData.ctorIdx | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} → {inst : Ord α} → Std.DTreeMap.Internal.Unit.RocSliceData α → ℕ | false |
Bornology.isVonNBounded_add_self | Mathlib.Analysis.LocallyConvex.Bounded | ∀ {𝕜 : Type u_1} {E : Type u_3} [inst : NormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [ContinuousSMul 𝕜 E] [ContinuousAdd E] {s : Set E},
Bornology.IsVonNBounded 𝕜 (s + s) ↔ Bornology.IsVonNBounded 𝕜 s | true |
_private.Lean.Elab.PreDefinition.Structural.SmartUnfolding.0.Lean.Elab.Structural.addSmartUnfoldingDefAux.visit.match_8 | Lean.Elab.PreDefinition.Structural.SmartUnfolding | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam binderName binderType body binderInfo)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
((n : Lean.Name) →
(type val body : Lean.Expr) → (nondep : Bool) → motive (Lean.Expr.letE n type val body nondep)) →
((d : Lean.MData) → (b : Lean.Expr) → motive (Lean.Expr.mdata d b)) →
((n : Lean.Name) → (i : ℕ) → (s : Lean.Expr) → motive (Lean.Expr.proj n i s)) →
((fn arg : Lean.Expr) → motive (fn.app arg)) → ((x : Lean.Expr) → motive x) → motive e | false |
LE.opposite_def | Init.Data.Order.Opposite | ∀ {α : Type u_1} {le : LE α}, le.opposite = { le := fun a b => b ≤ a } | true |
AddMonoidAlgebra.prod_single | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_4} {ι : Type u_7} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] (s : Finset ι)
(m : ι → M) (r : ι → R),
∏ i ∈ s, AddMonoidAlgebra.single (m i) (r i) = AddMonoidAlgebra.single (∑ i ∈ s, m i) (∏ i ∈ s, r i) | true |
Lean.Elab.Tactic.evalSeq1._regBuiltin.Lean.Elab.Tactic.evalSeq1_1 | Lean.Elab.Tactic.BuiltinTactic | IO Unit | false |
Polynomial.IsUnitTrinomial.irreducible_of_coprime' | Mathlib.Analysis.Complex.Polynomial.UnitTrinomial | ∀ {p : Polynomial ℤ},
p.IsUnitTrinomial → (∀ (z : ℂ), ¬((Polynomial.aeval z) p = 0 ∧ (Polynomial.aeval z) p.mirror = 0)) → Irreducible p | true |
CategoryTheory.Arrow.mapCechNerve._proof_1 | Mathlib.AlgebraicTopology.CechNerve | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {f g : CategoryTheory.Arrow C}
[inst_1 : ∀ (n : ℕ), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom] (F : f ⟶ g)
(n : SimplexCategoryᵒᵖ) (j : Fin ((Opposite.unop n).len + 1)),
CategoryTheory.CategoryStruct.comp
((fun i => CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.WidePullback.π (fun x => f.hom) i) F.left) j)
g.hom =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.WidePullback.base fun x => f.hom) F.right | false |
Submodule.sndEquiv_apply | Mathlib.LinearAlgebra.Prod | ∀ (R : Type u) (M : Type v) (M₂ : Type w) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M₂]
[inst_3 : Module R M] [inst_4 : Module R M₂] (x : ↥(Submodule.snd R M M₂)), (Submodule.sndEquiv R M M₂) x = (↑x).2 | true |
Polynomial.aevalAevalEquiv_symm_apply_snd | Mathlib.Algebra.Polynomial.Bivariate | ∀ (R : Type u_1) (A : Type u_2) [inst : CommSemiring R] [inst_1 : CommSemiring A] [inst_2 : Algebra R A]
(f : Polynomial (Polynomial R) →ₐ[R] A), ((Polynomial.aevalAevalEquiv R A).symm f).2 = f Polynomial.X | true |
ProbabilityTheory.centralMoment_two_eq_variance | Mathlib.Probability.Moments.Basic | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {X : Ω → ℝ} {μ : MeasureTheory.Measure Ω},
AEMeasurable X μ → ProbabilityTheory.centralMoment X 2 μ = ProbabilityTheory.variance X μ | true |
MeasureTheory.IntegrableOn.congr_set_ae | Mathlib.MeasureTheory.Integral.IntegrableOn | ∀ {α : Type u_1} {ε : Type u_3} {mα : MeasurableSpace α} {f : α → ε} {s t : Set α} {μ : MeasureTheory.Measure α}
[inst : TopologicalSpace ε] [inst_1 : ContinuousENorm ε],
MeasureTheory.IntegrableOn f t μ → s =ᵐ[μ] t → MeasureTheory.IntegrableOn f s μ | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.