name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Std.DHashMap.Internal.Raw₀.Const.any_toList | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β) {p : α → β → Bool},
((Std.DHashMap.Raw.Const.toList ↑m).any fun x => p x.1 x.2) = (↑m).any p |
Std.Time.Timestamp.ofPlainDateTimeAssumingUTC | Std.Time.DateTime | Std.Time.PlainDateTime → Std.Time.Timestamp |
CategoryTheory.Abelian.SpectralObject.leftHomologyDataShortComplex._auto_1 | Mathlib.Algebra.Homology.SpectralObject.Page | Lean.Syntax |
CuspFormClass.rec | Mathlib.NumberTheory.ModularForms.Basic | {F : Type u_2} →
{Γ : Subgroup (GL (Fin 2) ℝ)} →
{k : ℤ} →
[inst : FunLike F UpperHalfPlane ℂ] →
{motive : CuspFormClass F Γ k → Sort u} →
([toSlashInvariantFormClass : SlashInvariantFormClass F Γ k] →
(holo : ∀ (f : F), MDiff ⇑f) →
(zero_at_cusps : ∀ (f : F) {c : OnePoint ℝ}, IsCusp c Γ → c.IsZeroAt (⇑f) k) → motive ⋯) →
(t : CuspFormClass F Γ k) → motive t |
Turing.TM1to1.trCfg.eq_1 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {Λ : Type u_2} {σ : Type u_3} {n : ℕ} (enc : Γ → List.Vector Bool n) [inst : Inhabited Γ]
(enc0 : enc default = List.Vector.replicate n false) (l : Option Λ) (v : σ) (T : Turing.Tape Γ),
Turing.TM1to1.trCfg enc enc0 { l := l, var := v, Tape := T } =
{ l := Option.map Turing.TM1to1.Λ'.normal l, var := v, Tape := Turing.TM1to1.trTape enc0 T } |
GroupExtension.Splitting.conjAct | Mathlib.GroupTheory.GroupExtension.Basic | {N : Type u_1} →
{G : Type u_2} →
[inst : Group N] →
[inst_1 : Group G] →
{E : Type u_3} → [inst_2 : Group E] → {S : GroupExtension N E G} → S.Splitting → G →* MulAut N |
Std.HashMap.Raw.getElem_congr | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [inst_2 : EquivBEq α]
[inst_3 : LawfulHashable α] (h : m.WF) {a b : α} (hab : (a == b) = true) {h' : a ∈ m}, m[a] = m[b] |
RatFunc.irreducible_minpolyX | Mathlib.FieldTheory.RatFunc.Luroth | ∀ {K : Type u_1} [inst : Field K] (f : RatFunc K), (¬∃ c, f = RatFunc.C c) → Irreducible (f.minpolyX ↥K⟮f⟯) |
WeakSpace.instModule' | Mathlib.Topology.Algebra.Module.WeakDual | {𝕜 : Type u_2} →
{𝕝 : Type u_3} →
{E : Type u_4} →
[inst : CommSemiring 𝕜] →
[inst_1 : TopologicalSpace 𝕜] →
[inst_2 : ContinuousAdd 𝕜] →
[inst_3 : ContinuousConstSMul 𝕜 𝕜] →
[inst_4 : AddCommMonoid E] →
[inst_5 : Module 𝕜 E] →
[inst_6 : TopologicalSpace E] → [inst_7 : CommSemiring 𝕝] → [Module 𝕝 E] → Module 𝕝 (WeakSpace 𝕜 E) |
CategoryTheory.Subfunctor.range | Mathlib.CategoryTheory.Subfunctor.Image | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F F' : CategoryTheory.Functor C (Type w)} → (F' ⟶ F) → CategoryTheory.Subfunctor F |
QuaternionAlgebra.equivProd | Mathlib.Algebra.Quaternion | {R : Type u_1} → (c₁ c₂ c₃ : R) → QuaternionAlgebra R c₁ c₂ c₃ ≃ R × R × R × R |
Vector.set_mk._proof_3 | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Array α} (h : xs.size = n) {i : ℕ} {x : α} (w : i < n), (xs.set i x ⋯).size = n |
ContDiffOn.pow | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {s : Set E} {n : WithTop ℕ∞} {𝔸 : Type u_3} [inst_3 : NormedRing 𝔸]
[inst_4 : NormedAlgebra 𝕜 𝔸] {f : E → 𝔸}, ContDiffOn 𝕜 n f s → ∀ (m : ℕ), ContDiffOn 𝕜 n (fun y => f y ^ m) s |
Std.Internal.IO.Async.UDP.Socket.getPeerName | Std.Internal.Async.UDP | Std.Internal.IO.Async.UDP.Socket → IO Std.Net.SocketAddress |
Aesop.GoalOrigin | Aesop.Tree.Data | Type |
Submodule.span_smul | Mathlib.Algebra.Module.Submodule.Pointwise | ∀ {α : Type u_1} {R : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Monoid α] [inst_4 : DistribMulAction α M] [inst_5 : SMulCommClass α R M] (a : α) (s : Set M),
Submodule.span R (a • s) = a • Submodule.span R s |
_private.Mathlib.Probability.Distributions.Gaussian.Real.0.ProbabilityTheory.complexMGF_id_gaussianReal._simp_1_5 | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False |
Lean.Meta.Grind.InjectiveInfo.inv? | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.InjectiveInfo → Option (Lean.Expr × Lean.Expr) |
_private.Mathlib.CategoryTheory.Triangulated.Opposite.OpOp.0.CategoryTheory.Pretriangulated.commShiftIso_opOp_hom_app._proof_3 | Mathlib.CategoryTheory.Triangulated.Opposite.OpOp | ∀ (n m : ℤ), autoParam (n + m = 0) CategoryTheory.Pretriangulated.commShiftIso_opOp_hom_app._auto_1 → m + n = 0 |
_private.Mathlib.GroupTheory.Descent.0.Group.fg_of_descent._simp_1_4 | Mathlib.GroupTheory.Descent | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False |
Valuation.val_le_one_or_val_inv_lt_one | Mathlib.RingTheory.Valuation.Basic | ∀ {K : Type u_1} [inst : DivisionRing K] {Γ₀ : Type u_4} [inst_1 : LinearOrderedCommGroupWithZero Γ₀]
(v : Valuation K Γ₀) (x : K), v x ≤ 1 ∨ v x⁻¹ < 1 |
Lean.Grind.IntInterval.lo?.eq_4 | Init.Grind.ToIntLemmas | Lean.Grind.IntInterval.ii.lo? = none |
AddAction.stabilizer.eq_1 | Mathlib.GroupTheory.GroupAction.Defs | ∀ (G : Type u_1) {α : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G α] (a : α),
AddAction.stabilizer G a = { toAddSubmonoid := AddAction.stabilizerAddSubmonoid G a, neg_mem' := ⋯ } |
ContinuousMultilinearMap.nnnorm_constOfIsEmpty | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ (𝕜 : Type u) {ι : Type v} (E : ι → Type wE) {G : Type wG} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : Fintype ι] [inst_6 : IsEmpty ι] (x : G),
‖ContinuousMultilinearMap.constOfIsEmpty 𝕜 E x‖₊ = ‖x‖₊ |
groupCohomology.Hilbert90.aux.eq_1 | Mathlib.RepresentationTheory.Homological.GroupCohomology.Hilbert90 | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
[inst_3 : FiniteDimensional K L] (f : Gal(L/K) → Lˣ),
groupCohomology.Hilbert90.aux f =
(Finsupp.linearCombination L fun φ => ⇑φ) (Finsupp.equivFunOnFinite.symm fun φ => ↑(f φ)) |
Polynomial.Monic.degree_pos | Mathlib.Algebra.Polynomial.Degree.Operations | ∀ {R : Type u} [inst : CommSemiring R] {p : Polynomial R}, p.Monic → (0 < p.degree ↔ p ≠ 1) |
SeparationQuotient.instDistrib._proof_1 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : Distrib R] [inst_2 : ContinuousAdd R] (a b : R),
SeparationQuotient.mk (a + b) = SeparationQuotient.mk a + SeparationQuotient.mk b |
_private.Mathlib.Data.List.TakeDrop.0.List.takeD_eq_take.match_1_1 | Mathlib.Data.List.TakeDrop | ∀ {α : Type u_1} (motive : (x : ℕ) → (x_1 : List α) → α → x ≤ x_1.length → Prop) (x : ℕ) (x_1 : List α) (x_2 : α)
(x_3 : x ≤ x_1.length),
(∀ (x : List α) (x_4 : α) (x_5 : 0 ≤ x.length), motive 0 x x_4 x_5) →
(∀ (n : ℕ) (head : α) (tail : List α) (a : α) (h : n + 1 ≤ (head :: tail).length),
motive n.succ (head :: tail) a h) →
motive x x_1 x_2 x_3 |
Lean.instInhabitedTheoremVal | Lean.Declaration | Inhabited Lean.TheoremVal |
t1Space_iff_specializes_imp_eq | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X], T1Space X ↔ ∀ ⦃x y : X⦄, x ⤳ y → x = y |
Submodule.IsOrtho.le | Mathlib.Analysis.InnerProductSpace.Orthogonal | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{U V : Submodule 𝕜 E}, U ⟂ V → U ≤ Vᗮ |
AdicCompletion.of_injective | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) (M : Type u_4) [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[IsHausdorff I M], Function.Injective ⇑(AdicCompletion.of I M) |
MeasureTheory.Measure.pi | Mathlib.MeasureTheory.Constructions.Pi | {ι : Type u_4} →
{α : ι → Type u_5} →
[Fintype ι] →
[inst : (i : ι) → MeasurableSpace (α i)] →
((i : ι) → MeasureTheory.Measure (α i)) → MeasureTheory.Measure ((i : ι) → α i) |
Std.Internal.IO.Async.Signal.sigxfsz.elim | Std.Internal.Async.Signal | {motive : Std.Internal.IO.Async.Signal → Sort u} →
(t : Std.Internal.IO.Async.Signal) → t.ctorIdx = 17 → motive Std.Internal.IO.Async.Signal.sigxfsz → motive t |
MonoidWithZeroHom | Mathlib.Algebra.GroupWithZero.Hom | (α : Type u_7) → (β : Type u_8) → [MulZeroOneClass α] → [MulZeroOneClass β] → Type (max u_7 u_8) |
_private.Mathlib.GroupTheory.GroupAction.SubMulAction.Pointwise.0.SubMulAction.instMulOneClass._simp_1 | Mathlib.GroupTheory.GroupAction.SubMulAction.Pointwise | ∀ {R : Type u_1} {M : Type u_2} [inst : Monoid R] [inst_1 : MulAction R M] [inst_2 : Mul M]
[inst_3 : IsScalarTower R M M] {p q : SubMulAction R M} {x : M}, (x ∈ p * q) = ∃ y ∈ p, ∃ z ∈ q, y * z = x |
Std.DTreeMap.Internal.Impl.Const.get!_insertIfNew! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α]
[inst : Inhabited β],
t.WF →
∀ {k a : α} {v : β},
Std.DTreeMap.Internal.Impl.Const.get! (Std.DTreeMap.Internal.Impl.insertIfNew! k v t) a =
if compare k a = Ordering.eq ∧ k ∉ t then v else Std.DTreeMap.Internal.Impl.Const.get! t a |
Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVExpr.mkBVConst | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr | {w : ℕ} → BitVec w → Lean.Elab.Tactic.BVDecide.Frontend.M Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVExpr |
ContDiffOn.continuousOn_fderivWithin_apply | Mathlib.Analysis.Calculus.ContDiff.Comp | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E} {f : E → F}
{n : WithTop ℕ∞},
ContDiffOn 𝕜 n f s → UniqueDiffOn 𝕜 s → 1 ≤ n → ContinuousOn (fun p => (fderivWithin 𝕜 f s p.1) p.2) (s ×ˢ Set.univ) |
MultiplierAlgebra.«_aux_Mathlib_Analysis_CStarAlgebra_Multiplier___macroRules_MultiplierAlgebra_term𝓜(_,_)_1» | Mathlib.Analysis.CStarAlgebra.Multiplier | Lean.Macro |
iteratedFDerivWithin_insert | Mathlib.Analysis.Calculus.ContDiff.FTaylorSeries | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
{f : E → F} {x : E} {n : ℕ} {y : E}, iteratedFDerivWithin 𝕜 n f (insert x s) y = iteratedFDerivWithin 𝕜 n f s y |
Finite.ciInf_le_of_le | Mathlib.Data.Fintype.Order | ∀ {α : Type u_1} {ι : Type u_2} [Finite ι] [inst : ConditionallyCompleteLattice α] {a : α} {f : ι → α} (c : ι),
f c ≤ a → iInf f ≤ a |
AddActionHom.inverse._proof_2 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_2} {X : Type u_1} [inst : VAdd M X] {Y₁ : Type u_3} [inst_1 : VAdd M Y₁] (f : X →ₑ[id] Y₁) (g : Y₁ → X)
(m : M) (x : Y₁), g (m +ᵥ f (g x)) = g (f (m +ᵥ g x)) |
Lean.Meta.Simp.debug.simp.check.have | Lean.Meta.Tactic.Simp.Main | Lean.Option Bool |
_private.Aesop.Script.Step.0.Aesop.Script.LazyStep.runFirstSuccessfulTacticBuilder.tryTacticBuilder.match_4 | Aesop.Script.Step | (motive : Option (Lean.Meta.SavedState × List Lean.MVarId) → Sort u_1) →
(tacticResult : Option (Lean.Meta.SavedState × List Lean.MVarId)) →
((actualPostState : Lean.Meta.SavedState) →
(actualPostGoals : List Lean.MVarId) → motive (some (actualPostState, actualPostGoals))) →
((x : Option (Lean.Meta.SavedState × List Lean.MVarId)) → motive x) → motive tacticResult |
_private.Mathlib.Order.Cover.0.LT.lt.exists_disjoint_Iio_Ioi._proof_1_1 | Mathlib.Order.Cover | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, a < b → ∃ a', a < a' ∧ ∃ b' < b, ∀ x < a', ∀ (y : α), b' < y → x < y |
String.Slice.getUTF8Byte.eq_1 | Init.Data.String.Basic | ∀ (s : String.Slice) (p : String.Pos.Raw) (h : p < s.rawEndPos),
s.getUTF8Byte p h = s.str.getUTF8Byte (p.offsetBy s.startInclusive.offset) ⋯ |
Mathlib.Tactic.UnfoldBoundary.UnfoldBoundaries.recOn | Mathlib.Tactic.Translate.UnfoldBoundary | {motive : Mathlib.Tactic.UnfoldBoundary.UnfoldBoundaries → Sort u} →
(t : Mathlib.Tactic.UnfoldBoundary.UnfoldBoundaries) →
((unfolds : Lean.NameMap Lean.Meta.SimpTheorem) →
(casts : Lean.NameMap (Lean.Name × Lean.Name)) →
(insertionFuns : Lean.NameSet) →
motive { unfolds := unfolds, casts := casts, insertionFuns := insertionFuns }) →
motive t |
ContinuousMap.HomotopicRel.symm | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {S : Set X} ⦃f g : C(X, Y)⦄,
f.HomotopicRel g S → g.HomotopicRel f S |
Polynomial.roots_map_of_injective_of_card_eq_natDegree | Mathlib.Algebra.Polynomial.Roots | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : IsDomain A] [inst_3 : IsDomain B]
{p : Polynomial A} {f : A →+* B},
Function.Injective ⇑f → p.roots.card = p.natDegree → Multiset.map (⇑f) p.roots = (Polynomial.map f p).roots |
Int8.ofUInt8.sizeOf_spec | Init.Data.SInt.Basic | ∀ (toUInt8 : UInt8), sizeOf { toUInt8 := toUInt8 } = 1 + sizeOf toUInt8 |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.String.0._regBuiltin.String.reducePush.declare_28._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.String.1574800046._hygCtx._hyg.14 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.String | IO Unit |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.ReorderVars.0.Lean.Meta.Grind.Arith.Cutsat.updateVarCoeff | Lean.Meta.Tactic.Grind.Arith.Cutsat.ReorderVars | ℤ → Int.Linear.Var → Lean.Meta.Grind.Arith.Cutsat.CollectM✝ Unit |
Matrix.IsAdjMatrix.apply_diag | Mathlib.Combinatorics.SimpleGraph.AdjMatrix | ∀ {α : Type u_1} {V : Type u_2} [inst : Zero α] [inst_1 : One α] {A : Matrix V V α},
A.IsAdjMatrix → ∀ (i : V), A i i = 0 |
Real.sin_arctan_lt_zero | Mathlib.Analysis.SpecialFunctions.Trigonometric.Arctan | ∀ {x : ℝ}, Real.sin (Real.arctan x) < 0 ↔ x < 0 |
SSet.N.eq_iff | Mathlib.AlgebraicTopology.SimplicialSet.NonDegenerateSimplices | ∀ {X : SSet} {x y : X.N}, x = y ↔ x.subcomplex = y.subcomplex |
Aesop.NormalizationState.isNormal | Aesop.Tree.Data | Aesop.NormalizationState → Bool |
String.Slice.posGT_le_iff | Init.Data.String.Lemmas.FindPos | ∀ {s : String.Slice} {p : String.Pos.Raw} {h : p < s.rawEndPos} {q : s.Pos}, s.posGT p h ≤ q ↔ p < q.offset |
Zero.ctorIdx | Init.Prelude | {α : Type u} → Zero α → ℕ |
Matrix.toLpLinAlgEquiv_symm_apply | Mathlib.Analysis.Normed.Lp.Matrix | ∀ {n : Type u_2} {R : Type u_4} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing R] (p : ENNReal)
(a : Module.End R (WithLp p (n → R))), (Matrix.toLpLinAlgEquiv p).symm a = (Matrix.toLpLin p p).symm a |
Lean.Elab.TerminationBy.synthetic | Lean.Elab.PreDefinition.TerminationHint | Lean.Elab.TerminationBy → Bool |
Mathlib.Tactic.BicategoryLike.Mor₂.comp.sizeOf_spec | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | ∀ (e : Lean.Expr) (isoLift? : Option Mathlib.Tactic.BicategoryLike.IsoLift) (f g h : Mathlib.Tactic.BicategoryLike.Mor₁)
(η θ : Mathlib.Tactic.BicategoryLike.Mor₂),
sizeOf (Mathlib.Tactic.BicategoryLike.Mor₂.comp e isoLift? f g h η θ) =
1 + sizeOf e + sizeOf isoLift? + sizeOf f + sizeOf g + sizeOf h + sizeOf η + sizeOf θ |
_private.Lean.Meta.Sym.InstantiateS.0.Lean.Meta.Sym.instantiateRevRangeS._proof_1 | Lean.Meta.Sym.InstantiateS | ∀ (beginIdx endIdx : ℕ) (subst : Array Lean.Expr),
¬beginIdx > endIdx →
¬endIdx > subst.size →
∀ (offset idx : ℕ),
idx ≥ beginIdx + offset →
idx < offset + (endIdx - beginIdx) → endIdx - beginIdx - (idx - offset) - 1 < subst.size |
Manifold.«_aux_Mathlib_Geometry_Manifold_ContMDiffMap___macroRules_Manifold_termC^_⟮_,_;_⟯_1» | Mathlib.Geometry.Manifold.ContMDiffMap | Lean.Macro |
GradedMonoid.GSMul.rec | Mathlib.Algebra.GradedMulAction | {ιA : Type u_1} →
{ιM : Type u_3} →
{A : ιA → Type u_4} →
{M : ιM → Type u_5} →
[inst : VAdd ιA ιM] →
{motive : GradedMonoid.GSMul A M → Sort u} →
((smul : {i : ιA} → {j : ιM} → A i → M j → M (i +ᵥ j)) → motive { smul := smul }) →
(t : GradedMonoid.GSMul A M) → motive t |
Std.Time.TimeZone.TZif.TZifV2._sizeOf_inst | Std.Time.Zoned.Database.TzIf | SizeOf Std.Time.TimeZone.TZif.TZifV2 |
PresheafOfModules.evaluationJointlyReflectsLimits | Mathlib.Algebra.Category.ModuleCat.Presheaf.Limits | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{R : CategoryTheory.Functor Cᵒᵖ RingCat} →
{J : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} J] →
(F : CategoryTheory.Functor J (PresheafOfModules R)) →
[∀ (X : Cᵒᵖ),
Small.{v, max u₂ v}
↑((F.comp (PresheafOfModules.evaluation R X)).comp
(CategoryTheory.forget (ModuleCat ↑(R.obj X)))).sections] →
(c : CategoryTheory.Limits.Cone F) →
((X : Cᵒᵖ) → CategoryTheory.Limits.IsLimit ((PresheafOfModules.evaluation R X).mapCone c)) →
CategoryTheory.Limits.IsLimit c |
EstimatorData.ctorIdx | Mathlib.Deprecated.Estimator | {α : Type u_1} → {a : Thunk α} → {ε : Type u_3} → EstimatorData a ε → ℕ |
_private.Mathlib.RingTheory.Spectrum.Prime.Topology.0.PrimeSpectrum.localization_away_comap_range._simp_1_3 | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {α : Type u_1} {a : α} {s : Set α}, ({a} ⊆ s) = (a ∈ s) |
Submodule.equivMapOfInjective._proof_4 | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_3} {R₂ : Type u_4} {M : Type u_1} {M₂ : Type u_2} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂}
(f : M →ₛₗ[σ₁₂] M₂) (i : Function.Injective ⇑f) (p : Submodule R M),
Function.RightInverse (Equiv.Set.image (⇑f) (↑p) i).invFun (Equiv.Set.image (⇑f) (↑p) i).toFun |
Mathlib.PrintSorries.State.mk.inj | Mathlib.Util.PrintSorries | ∀ {visited : Lean.NameSet} {sorries : Std.HashSet Lean.Expr} {sorryMsgs : Array Lean.MessageData}
{visited_1 : Lean.NameSet} {sorries_1 : Std.HashSet Lean.Expr} {sorryMsgs_1 : Array Lean.MessageData},
{ visited := visited, sorries := sorries, sorryMsgs := sorryMsgs } =
{ visited := visited_1, sorries := sorries_1, sorryMsgs := sorryMsgs_1 } →
visited = visited_1 ∧ sorries = sorries_1 ∧ sorryMsgs = sorryMsgs_1 |
NonUnitalStarSubalgebra.toNonUnitalSubring_injective | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} [inst : CommRing R] [inst_1 : NonUnitalRing A] [inst_2 : Module R A] [inst_3 : Star A],
Function.Injective NonUnitalStarSubalgebra.toNonUnitalSubring |
Lean.ErrorExplanation.Metadata.removedVersion? | Lean.ErrorExplanation | Lean.ErrorExplanation.Metadata → Option String |
CategoryTheory.sheafificationNatIso | Mathlib.CategoryTheory.Sites.Sheafification | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(J : CategoryTheory.GrothendieckTopology C) →
(D : Type u_1) →
[inst_1 : CategoryTheory.Category.{v_1, u_1} D] →
[inst_2 : CategoryTheory.HasWeakSheafify J D] →
CategoryTheory.Functor.id (CategoryTheory.Sheaf J D) ≅
(CategoryTheory.sheafToPresheaf J D).comp (CategoryTheory.presheafToSheaf J D) |
RelIso.sumLexComplRight_symm_apply | Mathlib.Order.Hom.Lex | ∀ {α : Type u_1} {r : α → α → Prop} {x : α} [inst : IsTrans α r] [inst_1 : Std.Trichotomous r] [inst_2 : DecidableRel r]
(a : { x_1 // ¬r x x_1 } ⊕ Subtype (r x)), (RelIso.sumLexComplRight r x) a = (Equiv.sumCompl (r x)) a.swap |
CategoryTheory.ShortComplex.RightHomologyMapData.comp_φQ | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ S₃ : CategoryTheory.ShortComplex C} {φ : S₁ ⟶ S₂} {φ' : S₂ ⟶ S₃} {h₁ : S₁.RightHomologyData}
{h₂ : S₂.RightHomologyData} {h₃ : S₃.RightHomologyData} (ψ : CategoryTheory.ShortComplex.RightHomologyMapData φ h₁ h₂)
(ψ' : CategoryTheory.ShortComplex.RightHomologyMapData φ' h₂ h₃),
(ψ.comp ψ').φQ = CategoryTheory.CategoryStruct.comp ψ.φQ ψ'.φQ |
WithSeminorms.hasBasis_ball | Mathlib.Analysis.LocallyConvex.WithSeminorms | ∀ {𝕜 : Type u_2} {E : Type u_6} {ι : Type u_9} [inst : NormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {p : SeminormFamily 𝕜 E ι},
WithSeminorms p → ∀ {x : E}, (nhds x).HasBasis (fun sr => 0 < sr.2) fun sr => (sr.1.sup p).ball x sr.2 |
List.sortedLE_ofFn_iff | Mathlib.Data.List.Sort | ∀ {α : Type u_1} [inst : Preorder α] {n : ℕ} {f : Fin n → α}, (List.ofFn f).SortedLE ↔ Monotone f |
Rel.edgeDensity.congr_simp | Mathlib.Combinatorics.SimpleGraph.Density | ∀ {α : Type u_4} {β : Type u_5} (r r_1 : α → β → Prop),
r = r_1 →
∀ {inst : (a : α) → DecidablePred (r a)} [inst_1 : (a : α) → DecidablePred (r_1 a)] (s s_1 : Finset α),
s = s_1 → ∀ (t t_1 : Finset β), t = t_1 → Rel.edgeDensity r s t = Rel.edgeDensity r_1 s_1 t_1 |
CategoryTheory.CostructuredArrow.toOverCompYoneda._proof_1 | Mathlib.CategoryTheory.Comma.Presheaf.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] (A : CategoryTheory.Functor Cᵒᵖ (Type u_2))
(T : CategoryTheory.Over A) {X Y : (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.CostructuredArrow.toOver CategoryTheory.yoneda A).op.comp (CategoryTheory.yoneda.obj T)).map f)
((fun X =>
(CategoryTheory.overEquivPresheafCostructuredArrow A).fullyFaithfulFunctor.homEquiv.toIso ≪≫
(((CategoryTheory.CostructuredArrow.toOverCompOverEquivPresheafCostructuredArrow A).app
(Opposite.unop X)).homCongr
(CategoryTheory.Iso.refl
((CategoryTheory.overEquivPresheafCostructuredArrow A).functor.obj T))).toIso)
Y).hom =
CategoryTheory.CategoryStruct.comp
((fun X =>
(CategoryTheory.overEquivPresheafCostructuredArrow A).fullyFaithfulFunctor.homEquiv.toIso ≪≫
(((CategoryTheory.CostructuredArrow.toOverCompOverEquivPresheafCostructuredArrow A).app
(Opposite.unop X)).homCongr
(CategoryTheory.Iso.refl
((CategoryTheory.overEquivPresheafCostructuredArrow A).functor.obj T))).toIso)
X).hom
((CategoryTheory.yoneda.op.comp
(CategoryTheory.yoneda.obj ((CategoryTheory.overEquivPresheafCostructuredArrow A).functor.obj T))).map
f) |
Lean.IR.LogEntry | Lean.Compiler.IR.CompilerM | Type |
Differentiable.continuous | Mathlib.Analysis.Calculus.FDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F} [ContinuousAdd E] [ContinuousSMul 𝕜 E] [ContinuousAdd F]
[ContinuousSMul 𝕜 F], Differentiable 𝕜 f → Continuous f |
Int64.sub_mul | Init.Data.SInt.Lemmas | ∀ {a b c : Int64}, (a - b) * c = a * c - b * c |
OrderHom.gfp_le | Mathlib.Order.FixedPoints | ∀ {α : Type u} [inst : CompleteLattice α] (f : α →o α) {a : α}, (∀ b ≤ f b, b ≤ a) → OrderHom.gfp f ≤ a |
_private.Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic.0.Algebra.finite_iff_isIntegral_and_finiteType.match_1_1 | Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic | ∀ {R : Type u_1} {A : Type u_2} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
(motive : Algebra.IsIntegral R A ∧ Algebra.FiniteType R A → Prop)
(x : Algebra.IsIntegral R A ∧ Algebra.FiniteType R A),
(∀ (h : Algebra.IsIntegral R A) (right : Algebra.FiniteType R A), motive ⋯) → motive x |
Lean.Compiler.LCNF.instInhabitedLetDecl | Lean.Compiler.LCNF.Basic | {a : Lean.Compiler.LCNF.Purity} → Inhabited (Lean.Compiler.LCNF.LetDecl a) |
Lean.Parser.Tactic.mcasesPatAlts | Std.Tactic.Do.Syntax | Lean.ParserDescr |
Nucleus.mem_toSublocale | Mathlib.Order.Sublocale | ∀ {X : Type u_1} [inst : Order.Frame X] {n : Nucleus X} {x : X}, x ∈ n.toSublocale ↔ ∃ y, n y = x |
ULift.div | Mathlib.Algebra.Group.ULift | {α : Type u} → [Div α] → Div (ULift.{u_1, u} α) |
CategoryTheory.LaxFunctor.mk.noConfusion | Mathlib.CategoryTheory.Bicategory.Functor.Lax | {B : Type u₁} →
{inst : CategoryTheory.Bicategory B} →
{C : Type u₂} →
{inst_1 : CategoryTheory.Bicategory C} →
{P : Sort u} →
{toPrelaxFunctor : CategoryTheory.PrelaxFunctor B C} →
{mapId :
(a : B) →
CategoryTheory.CategoryStruct.id (toPrelaxFunctor.obj a) ⟶
toPrelaxFunctor.map (CategoryTheory.CategoryStruct.id a)} →
{mapComp :
{a b c : B} →
(f : a ⟶ b) →
(g : b ⟶ c) →
CategoryTheory.CategoryStruct.comp (toPrelaxFunctor.map f) (toPrelaxFunctor.map g) ⟶
toPrelaxFunctor.map (CategoryTheory.CategoryStruct.comp f g)} →
{mapComp_naturality_left :
autoParam
(∀ {a b c : B} {f f' : a ⟶ b} (η : f ⟶ f') (g : b ⟶ c),
CategoryTheory.CategoryStruct.comp (mapComp f g)
(toPrelaxFunctor.map₂ (CategoryTheory.Bicategory.whiskerRight η g)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (toPrelaxFunctor.map₂ η) (toPrelaxFunctor.map g))
(mapComp f' g))
CategoryTheory.LaxFunctor.mapComp_naturality_left._autoParam} →
{mapComp_naturality_right :
autoParam
(∀ {a b c : B} (f : a ⟶ b) {g g' : b ⟶ c} (η : g ⟶ g'),
CategoryTheory.CategoryStruct.comp (mapComp f g)
(toPrelaxFunctor.map₂ (CategoryTheory.Bicategory.whiskerLeft f η)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft (toPrelaxFunctor.map f) (toPrelaxFunctor.map₂ η))
(mapComp f g'))
CategoryTheory.LaxFunctor.mapComp_naturality_right._autoParam} →
{map₂_associator :
autoParam
(∀ {a b c d : B} (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (mapComp f g) (toPrelaxFunctor.map h))
(CategoryTheory.CategoryStruct.comp (mapComp (CategoryTheory.CategoryStruct.comp f g) h)
(toPrelaxFunctor.map₂ (CategoryTheory.Bicategory.associator f g h).hom)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.associator (toPrelaxFunctor.map f) (toPrelaxFunctor.map g)
(toPrelaxFunctor.map h)).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft (toPrelaxFunctor.map f) (mapComp g h))
(mapComp f (CategoryTheory.CategoryStruct.comp g h))))
CategoryTheory.LaxFunctor.map₂_associator._autoParam} →
{map₂_leftUnitor :
autoParam
(∀ {a b : B} (f : a ⟶ b),
toPrelaxFunctor.map₂ (CategoryTheory.Bicategory.leftUnitor f).inv =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.leftUnitor (toPrelaxFunctor.map f)).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (mapId a) (toPrelaxFunctor.map f))
(mapComp (CategoryTheory.CategoryStruct.id a) f)))
CategoryTheory.LaxFunctor.map₂_leftUnitor._autoParam} →
{map₂_rightUnitor :
autoParam
(∀ {a b : B} (f : a ⟶ b),
toPrelaxFunctor.map₂ (CategoryTheory.Bicategory.rightUnitor f).inv =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.rightUnitor (toPrelaxFunctor.map f)).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft (toPrelaxFunctor.map f) (mapId b))
(mapComp f (CategoryTheory.CategoryStruct.id b))))
CategoryTheory.LaxFunctor.map₂_rightUnitor._autoParam} →
{toPrelaxFunctor' : CategoryTheory.PrelaxFunctor B C} →
{mapId' :
(a : B) →
CategoryTheory.CategoryStruct.id (toPrelaxFunctor'.obj a) ⟶
toPrelaxFunctor'.map (CategoryTheory.CategoryStruct.id a)} →
{mapComp' :
{a b c : B} →
(f : a ⟶ b) →
(g : b ⟶ c) →
CategoryTheory.CategoryStruct.comp (toPrelaxFunctor'.map f)
(toPrelaxFunctor'.map g) ⟶
toPrelaxFunctor'.map (CategoryTheory.CategoryStruct.comp f g)} →
{mapComp_naturality_left' :
autoParam
(∀ {a b c : B} {f f' : a ⟶ b} (η : f ⟶ f') (g : b ⟶ c),
CategoryTheory.CategoryStruct.comp (mapComp' f g)
(toPrelaxFunctor'.map₂ (CategoryTheory.Bicategory.whiskerRight η g)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (toPrelaxFunctor'.map₂ η)
(toPrelaxFunctor'.map g))
(mapComp' f' g))
CategoryTheory.LaxFunctor.mapComp_naturality_left._autoParam} →
{mapComp_naturality_right' :
autoParam
(∀ {a b c : B} (f : a ⟶ b) {g g' : b ⟶ c} (η : g ⟶ g'),
CategoryTheory.CategoryStruct.comp (mapComp' f g)
(toPrelaxFunctor'.map₂ (CategoryTheory.Bicategory.whiskerLeft f η)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft (toPrelaxFunctor'.map f)
(toPrelaxFunctor'.map₂ η))
(mapComp' f g'))
CategoryTheory.LaxFunctor.mapComp_naturality_right._autoParam} →
{map₂_associator' :
autoParam
(∀ {a b c d : B} (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (mapComp' f g)
(toPrelaxFunctor'.map h))
(CategoryTheory.CategoryStruct.comp
(mapComp' (CategoryTheory.CategoryStruct.comp f g) h)
(toPrelaxFunctor'.map₂
(CategoryTheory.Bicategory.associator f g h).hom)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.associator (toPrelaxFunctor'.map f)
(toPrelaxFunctor'.map g) (toPrelaxFunctor'.map h)).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft (toPrelaxFunctor'.map f)
(mapComp' g h))
(mapComp' f (CategoryTheory.CategoryStruct.comp g h))))
CategoryTheory.LaxFunctor.map₂_associator._autoParam} →
{map₂_leftUnitor' :
autoParam
(∀ {a b : B} (f : a ⟶ b),
toPrelaxFunctor'.map₂ (CategoryTheory.Bicategory.leftUnitor f).inv =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.leftUnitor (toPrelaxFunctor'.map f)).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (mapId' a)
(toPrelaxFunctor'.map f))
(mapComp' (CategoryTheory.CategoryStruct.id a) f)))
CategoryTheory.LaxFunctor.map₂_leftUnitor._autoParam} →
{map₂_rightUnitor' :
autoParam
(∀ {a b : B} (f : a ⟶ b),
toPrelaxFunctor'.map₂ (CategoryTheory.Bicategory.rightUnitor f).inv =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.rightUnitor (toPrelaxFunctor'.map f)).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft (toPrelaxFunctor'.map f)
(mapId' b))
(mapComp' f (CategoryTheory.CategoryStruct.id b))))
CategoryTheory.LaxFunctor.map₂_rightUnitor._autoParam} →
{ toPrelaxFunctor := toPrelaxFunctor, mapId := mapId, mapComp := mapComp,
mapComp_naturality_left := mapComp_naturality_left,
mapComp_naturality_right := mapComp_naturality_right,
map₂_associator := map₂_associator, map₂_leftUnitor := map₂_leftUnitor,
map₂_rightUnitor := map₂_rightUnitor } =
{ toPrelaxFunctor := toPrelaxFunctor', mapId := mapId',
mapComp := mapComp',
mapComp_naturality_left := mapComp_naturality_left',
mapComp_naturality_right := mapComp_naturality_right',
map₂_associator := map₂_associator',
map₂_leftUnitor := map₂_leftUnitor',
map₂_rightUnitor := map₂_rightUnitor' } →
(toPrelaxFunctor ≍ toPrelaxFunctor' →
mapId ≍ mapId' → mapComp ≍ mapComp' → P) →
P |
LinearIsometryEquiv.symm_conjStarAlgEquiv | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {H : Type u_5} [inst_1 : NormedAddCommGroup H] [inst_2 : InnerProductSpace 𝕜 H]
[inst_3 : CompleteSpace H] {K : Type u_6} [inst_4 : NormedAddCommGroup K] [inst_5 : InnerProductSpace 𝕜 K]
[inst_6 : CompleteSpace K] (e : H ≃ₗᵢ[𝕜] K), e.conjStarAlgEquiv.symm = e.symm.conjStarAlgEquiv |
CategoryTheory.Functor.prod._proof_2 | Mathlib.CategoryTheory.Products.Basic | ∀ {A : Type u_1} [inst : CategoryTheory.Category.{u_7, u_1} A] {B : Type u_5}
[inst_1 : CategoryTheory.Category.{u_3, u_5} B] {C : Type u_2} [inst_2 : CategoryTheory.Category.{u_8, u_2} C]
{D : Type u_6} [inst_3 : CategoryTheory.Category.{u_4, u_6} D] (F : CategoryTheory.Functor A B)
(G : CategoryTheory.Functor C D) (X : A × C),
CategoryTheory.Prod.mkHom (F.map (CategoryTheory.CategoryStruct.id X).1)
(G.map (CategoryTheory.CategoryStruct.id X).2) =
CategoryTheory.CategoryStruct.id (F.obj X.1, G.obj X.2) |
MeasureTheory.lintegral_lintegral_symm | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {μ : MeasureTheory.Measure α}
{ν : MeasureTheory.Measure β} [MeasureTheory.SFinite ν] [MeasureTheory.SFinite μ] ⦃f : α → β → ENNReal⦄,
AEMeasurable (Function.uncurry f) (μ.prod ν) →
∫⁻ (x : α), ∫⁻ (y : β), f x y ∂ν ∂μ = ∫⁻ (z : β × α), f z.2 z.1 ∂ν.prod μ |
CompactlySupportedContinuousMap._sizeOf_1 | Mathlib.Topology.ContinuousMap.CompactlySupported | {α : Type u_5} →
{β : Type u_6} →
{inst : TopologicalSpace α} →
{inst_1 : Zero β} →
{inst_2 : TopologicalSpace β} → [SizeOf α] → [SizeOf β] → CompactlySupportedContinuousMap α β → ℕ |
Mathlib.Tactic.BicategoryCoherence.LiftHom.recOn | Mathlib.Tactic.CategoryTheory.BicategoryCoherence | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b : B} →
{f : a ⟶ b} →
{motive : Mathlib.Tactic.BicategoryCoherence.LiftHom f → Sort u_1} →
(t : Mathlib.Tactic.BicategoryCoherence.LiftHom f) →
((lift : CategoryTheory.FreeBicategory.of.obj a ⟶ CategoryTheory.FreeBicategory.of.obj b) →
motive { lift := lift }) →
motive t |
StarMemClass.rec | Mathlib.Algebra.Star.Basic | {S : Type u_1} →
{R : Type u_2} →
[inst : Star R] →
[inst_1 : SetLike S R] →
{motive : StarMemClass S R → Sort u} →
((star_mem : ∀ {s : S} {r : R}, r ∈ s → star r ∈ s) → motive ⋯) → (t : StarMemClass S R) → motive t |
Std.IterM.stepSize | Std.Data.Iterators.Combinators.Monadic.StepSize | {α : Type u_1} →
{m : Type u_1 → Type u_2} →
{β : Type u_1} →
[inst : Std.Iterator α m β] → [Std.IteratorAccess α m] → [Monad m] → Std.IterM m β → ℕ → Std.IterM m β |
_private.Init.Data.BitVec.Bitblast.0.BitVec.ult_eq_not_carry._proof_1_6 | Init.Data.BitVec.Bitblast | ∀ {w : ℕ} (y : BitVec w), ¬2 ^ w - 1 - y.toNat < 2 ^ w → False |
ContinuousMap.Homotopy.extend_one | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f₀ f₁ : C(X, Y)}
(F : f₀.Homotopy f₁), F.extend 1 = f₁ |
MeasureTheory.exists_subordinate_pairwise_disjoint | Mathlib.MeasureTheory.Measure.NullMeasurable | ∀ {ι : Type u_1} {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [Countable ι] {s : ι → Set α},
(∀ (i : ι), MeasureTheory.NullMeasurableSet (s i) μ) →
Pairwise (Function.onFun (MeasureTheory.AEDisjoint μ) s) →
∃ t,
(∀ (i : ι), t i ⊆ s i) ∧
(∀ (i : ι), s i =ᵐ[μ] t i) ∧ (∀ (i : ι), MeasurableSet (t i)) ∧ Pairwise (Function.onFun Disjoint t) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.