name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ConvexCone.pointed_positive | Mathlib.Geometry.Convex.Cone.Basic | ∀ {R : Type u_2} {M : Type u_4} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : AddCommMonoid M]
[inst_3 : PartialOrder M] [inst_4 : IsOrderedAddMonoid M] [inst_5 : Module R M] [inst_6 : PosSMulMono R M],
(ConvexCone.positive R M).Pointed | The positive cone of an ordered module is always pointed. | true |
CategoryTheory.LaxFunctor._sizeOf_inst | Mathlib.CategoryTheory.Bicategory.Functor.Lax | (B : Type u₁) →
{inst : CategoryTheory.Bicategory B} →
(C : Type u₂) →
{inst_1 : CategoryTheory.Bicategory C} → [SizeOf B] → [SizeOf C] → SizeOf (CategoryTheory.LaxFunctor B C) | null | false |
_private.Lean.Meta.Tactic.Simp.Simproc.0.Lean.Meta.Simp.getSimprocFromDeclImpl.match_6 | Lean.Meta.Tactic.Simp.Simproc | (motive : Option Lean.ConstantInfo → Sort u_1) →
(x : Option Lean.ConstantInfo) → (Unit → motive none) → ((info : Lean.ConstantInfo) → motive (some info)) → motive x | null | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.le_min_iff._simp_1_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.OrientedCmp cmp] {a b : α},
(cmp a b = Ordering.gt) = (cmp b a = Ordering.lt) | null | false |
AddSubgroup.toIntSubmodule._proof_4 | Mathlib.Algebra.Module.Submodule.Lattice | ∀ {M : Type u_1} [inst : AddCommGroup M] {a b : AddSubgroup M},
{ toFun := fun S => { toAddSubmonoid := S.toAddSubmonoid, smul_mem' := ⋯ }, invFun := Submodule.toAddSubgroup,
left_inv := ⋯, right_inv := ⋯ }
a ≤
{ toFun := fun S => { toAddSubmonoid := S.toAddSubmonoid, smul_mem' := ⋯ }, invFun ... | null | false |
FirstOrder.Language.BoundedFormula.mapTermRel.eq_def | Mathlib.ModelTheory.Syntax | ∀ {L : FirstOrder.Language} {L' : FirstOrder.Language} {α : Type u'} {β : Type v'} {g : ℕ → ℕ}
(ft : (n : ℕ) → L.Term (α ⊕ Fin n) → L'.Term (β ⊕ Fin (g n))) (fr : (n : ℕ) → L.Relations n → L'.Relations n)
(h : (n : ℕ) → L'.BoundedFormula β (g (n + 1)) → L'.BoundedFormula β (g n + 1)) (x : ℕ) (x_1 : L.BoundedFormula... | null | true |
ModuleCat.biprodIsoProd_inv_comp_snd_apply | Mathlib.Algebra.Category.ModuleCat.Biproducts | ∀ {R : Type u} [inst : Ring R] (M N : ModuleCat R) (x : ↑M × ↑N),
(CategoryTheory.ConcreteCategory.hom CategoryTheory.Limits.biprod.snd)
((CategoryTheory.ConcreteCategory.hom (M.biprodIsoProd N).inv) x) =
x.2 | null | true |
Mathlib.Tactic.Translate.TranslateData.unfoldBoundaries? | Mathlib.Tactic.Translate.Core | Mathlib.Tactic.Translate.TranslateData → Option Mathlib.Tactic.UnfoldBoundary.UnfoldBoundaryExt | The `insert_cast`/`insert_cast_fun` attributes create an abstraction boundary for the tagged
constant when translating it. For example, `Set.Icc`, `Monotone`, `DecidableLT`, `WCovBy` are all
morally self-dual, but their definition is not self-dual. So, in order to allow these constants
to be self-dual, we need to not u... | true |
Std.Http.URI.instInhabitedQuery | Std.Http.Data.URI.Basic | Inhabited Std.Http.URI.Query | null | true |
BitVec.reduceHShiftLeft | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | Lean.Meta.Simp.DSimproc | Simplification procedure for shift left on `BitVec`. | true |
LocallyLipschitz.const_min | Mathlib.Topology.MetricSpace.Lipschitz | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {f : α → ℝ},
LocallyLipschitz f → ∀ (a : ℝ), LocallyLipschitz fun x => min a (f x) | null | true |
normalizedGCDMonoidOfLCM._proof_5 | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [IsCancelMulZero α] [inst_2 : NormalizationMonoid α]
[inst_3 : DecidableEq α] (lcm : α → α → α) (lcm_dvd : ∀ {a b c : α}, c ∣ a → b ∣ a → lcm c b ∣ a),
(∀ (a b : α), normalize (lcm a b) = lcm a b) →
∀ (a b : α),
normalize (if a = 0 then normalize b else if b ... | null | false |
Int.Linear.Poly | Init.Data.Int.Linear | Type | null | true |
Std.ExtHashSet.contains_iff_mem._simp_1 | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashSet α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
{a : α}, (m.contains a = true) = (a ∈ m) | null | false |
Lean.Elab.liftMacroM | Lean.Elab.Util | {m : Type → Type} →
{α : Type} →
[Monad m] →
[Lean.Elab.MonadMacroAdapter m] →
[Lean.MonadEnv m] →
[Lean.MonadRecDepth m] →
[Lean.MonadError m] →
[Lean.MonadResolveName m] →
[Lean.MonadTrace m] →
[Lean.MonadOptions m] → [Lean.AddM... | null | true |
Array.le_min?_iff | Init.Data.Array.MinMax | ∀ {α : Type u_1} {a : α} [inst : Min α] [inst_1 : LE α] [Std.LawfulOrderInf α] {xs : Array α},
xs.min? = some a → ∀ {x : α}, x ≤ a ↔ ∀ b ∈ xs, x ≤ b | null | true |
Lean.pp.rawOnError | Lean.Util.PPExt | Lean.Option Bool | null | true |
CategoryTheory.Pseudofunctor.hasCoeToLax | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] → Coe (CategoryTheory.Pseudofunctor B C) (CategoryTheory.LaxFunctor B C) | null | true |
_private.Init.Internal.Order.Basic.0.Lean.Order.admissible_pprod_snd.match_1_1 | Init.Internal.Order.Basic | ∀ {α : Sort u_1} {β : Sort u_2} [inst : Lean.Order.CCPO α] [inst_1 : Lean.Order.CCPO β] (c : α ×' β → Prop) (y : β)
(motive : Lean.Order.PProd.chain.snd c y → Prop) (h : Lean.Order.PProd.chain.snd c y),
(∀ (x : α) (hxy : c ⟨x, y⟩), motive ⋯) → motive h | null | false |
_private.Init.Data.Vector.Basic.0.Vector.mapM._proof_2 | Init.Data.Vector.Basic | ∀ {n : ℕ}, ∀ k ≤ n, ¬k < n → ¬k = n → False | null | false |
QuotientGroup.quotientInfEquivProdNormalQuotient.eq_1 | Mathlib.GroupTheory.QuotientGroup.Basic | ∀ {G : Type u} [inst : Group G] (H N : Subgroup G) [hN : N.Normal],
QuotientGroup.quotientInfEquivProdNormalQuotient H N = QuotientGroup.quotientInfEquivProdNormalizerQuotient H N ⋯ | null | true |
toIcoMod_intCast_mul_add' | Mathlib.Algebra.Order.ToIntervalMod | ∀ {R : Type u_1} [inst : NonAssocRing R] [inst_1 : LinearOrder R] [inst_2 : IsOrderedAddMonoid R]
[inst_3 : Archimedean R] {p : R} (hp : 0 < p) (a b : R) (m : ℤ), toIcoMod hp (↑m * p + a) b = ↑m * p + toIcoMod hp a b | null | true |
ProbabilityTheory.HasLaw.ae_eq_of_smul_dirac | Mathlib.Probability.HasLaw | ∀ {Ω : Type u_1} {𝓧 : Type u_2} {mΩ : MeasurableSpace Ω} {m𝓧 : MeasurableSpace 𝓧} {X : Ω → 𝓧}
{P : MeasureTheory.Measure Ω} {c : ENNReal} [MeasurableSingletonClass 𝓧] {x : 𝓧},
ProbabilityTheory.HasLaw X (c • MeasureTheory.Measure.dirac x) P → X =ᵐ[P] fun x_1 => x | null | true |
TensorProduct.AlgebraTensorModule.map._proof_1 | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ {R : Type u_1} {A : Type u_2} {P : Type u_4} {Q : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : AddCommMonoid P] [inst_4 : Module R P] [inst_5 : Module A P]
[inst_6 : IsScalarTower R A P] [inst_7 : AddCommMonoid Q] [inst_8 : Module R Q],
SMulCommClass R A (TensorProduc... | null | false |
CategoryTheory.Functor.mapHomologicalComplexUpToQuasiIsoFactorsh_hom_app_assoc | Mathlib.Algebra.Homology.Localization | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (F : CategoryTheory.Functor C D) {ι : Type u_3} {c : ComplexShape ι}
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Preadditive D]
[inst_4 : CategoryTheory.CategoryWithHo... | null | true |
_private.Mathlib.Data.EReal.Operations.0.ENNReal.toEReal_sub._simp_1_1 | Mathlib.Data.EReal.Operations | ∀ {r p : NNReal}, ↑r - ↑p = ↑(r - p) | null | false |
_private.Init.Data.String.Lemmas.Pattern.Basic.0.String.Slice.Pattern.Model.isLongestRevMatch_iff_isLongestRevMatchAt_ofSliceTo._simp_1_2 | Init.Data.String.Lemmas.Pattern.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat] {s : String.Slice} {base : s.Pos}
{startPos endPos : (s.sliceTo base).Pos},
String.Slice.Pattern.Model.IsLongestRevMatchAt pat startPos endPos =
String.Slice.Pattern.Model.IsLongestRevMatchAt pat (String.Slice.Pos.ofSliceTo startPos)
... | null | false |
addConGen._proof_1 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Add M] (r : M → M → Prop), Equivalence (AddConGen.Rel r) | null | false |
SemiNormedGrp₁.coe_of | Mathlib.Analysis.Normed.Group.SemiNormedGrp | ∀ (V : Type u) [inst : SeminormedAddCommGroup V], { carrier := V, str := inst }.carrier = V | null | true |
Std.Internal.Do.Spec.forIn'_roi._proof_2 | Std.Internal.Do.Triple.SpecLemmas | ∀ {α : Type u_1} [inst : LT α] [inst_1 : Std.PRange.UpwardEnumerable α] [inst_2 : Std.Rxi.IsAlwaysFinite α]
[inst_3 : Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLT α] {xs : Std.Roi α}
(pref : List α) (cur : α) (suff : List α), xs.toList = pref ++ cur :: suff → cur ∈ xs | null | false |
_private.Mathlib.Algebra.Ring.Periodic.0.Function.Antiperiodic.int_mul_eq_of_eq_zero.match_1_1 | Mathlib.Algebra.Ring.Periodic | ∀ (motive : ℤ → Prop) (x : ℤ), (∀ (n : ℕ), motive (Int.ofNat n)) → (∀ (n : ℕ), motive (Int.negSucc n)) → motive x | null | false |
sub_add_sub_cancel | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : AddGroup G] (a b c : G), a - b + (b - c) = a - c | null | true |
AdicCompletion.ofLinearEquiv.eq_1 | 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]
[inst_3 : IsAdicComplete I M], AdicCompletion.ofLinearEquiv I M = LinearEquiv.ofBijective (AdicCompletion.of I M) ⋯ | null | true |
Algebra.SubmersivePresentation.isStandardSmoothOfRelativeDimension | Mathlib.RingTheory.Smooth.StandardSmooth | ∀ {n : ℕ} {R : Type u} {S : Type v} {ι : Type w} {σ : Type t} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : Finite σ] [Finite ι] (P : Algebra.SubmersivePresentation R S ι σ),
P.dimension = n → Algebra.IsStandardSmoothOfRelativeDimension n R S | null | true |
ContinuousMap.toNNReal_algebraMap | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unique | ∀ {X : Type u_1} [inst : TopologicalSpace X] (r : NNReal),
((algebraMap ℝ C(X, ℝ)) ↑r).toNNReal = (algebraMap NNReal C(X, NNReal)) r | null | true |
_private.Mathlib.Algebra.Polynomial.Degree.TrailingDegree.0.Polynomial.natTrailingDegree_intCast._simp_1_1 | Mathlib.Algebra.Polynomial.Degree.TrailingDegree | ∀ {R : Type u} [inst : Ring R] (n : ℤ), ↑n = Polynomial.C ↑n | null | false |
CategoryTheory.EnrichedFunctor.obj | Mathlib.CategoryTheory.Enriched.Basic | {V : Type v} →
[inst : CategoryTheory.Category.{w, v} V] →
[inst_1 : CategoryTheory.MonoidalCategory V] →
{C : Type u₁} →
[inst_2 : CategoryTheory.EnrichedCategory V C] →
{D : Type u₂} → [inst_3 : CategoryTheory.EnrichedCategory V D] → CategoryTheory.EnrichedFunctor V C D → C → D | The application of this functor to an object | true |
iteratedDeriv_div_const | Mathlib.Analysis.Calculus.IteratedDeriv.Lemmas | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {𝕜' : Type u_6} [inst_1 : NormedDivisionRing 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] {n : ℕ} (f : 𝕜 → 𝕜') (c : 𝕜'),
iteratedDeriv n (fun x => f x / c) x = iteratedDeriv n f x / c | null | true |
_private.Mathlib.Data.List.Dedup.0.List.dedup_cons_of_mem'._simp_1_2 | Mathlib.Data.List.Dedup | ∀ {a : Prop}, (¬¬a) = a | null | false |
MvQPF.Comp.map' | Mathlib.Data.QPF.Multivariate.Constructions.Comp | {n m : ℕ} →
{G : Fin2 n → TypeVec.{u} m → Type u} →
{α β : TypeVec.{u} m} → α.Arrow β → [(i : Fin2 n) → MvFunctor (G i)] → TypeVec.Arrow (fun i => G i α) fun i => G i β | map operation defined on a vector of functors | true |
MeasureTheory.measure_eq_top_of_setLIntegral_ne_top | Mathlib.MeasureTheory.Integral.Lebesgue.Markov | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ENNReal} {s : Set α},
AEMeasurable f (μ.restrict s) → ∫⁻ (x : α) in s, f x ∂μ ≠ ⊤ → μ {x | x ∈ s ∧ f x = ⊤} = 0 | null | true |
Std.TreeMap.contains_insert_self | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α} {v : β},
(t.insert k v).contains k = true | null | true |
_private.Mathlib.Data.List.Cycle.0.Cycle.chain_of_pairwise._proof_1_1 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {r : α → α → Prop} (a : α) (l : List α),
(∀ a_1 ∈ ↑(a :: l), ∀ b ∈ ↑(a :: l), r a_1 b) →
a ∈ ↑(a :: l) → (∀ {b : α}, b ∈ l → b ∈ ↑(a :: l)) → ∀ b ∈ l ++ [a], r a b | null | false |
EIO.catchExceptions | Init.System.IO | {ε α : Type} → EIO ε α → (ε → BaseIO α) → BaseIO α | Handles any exception that might be thrown by an `EIO ε` action, transforming it into an
exception-free `BaseIO` action.
| true |
NNReal.toReal_ne._simp_1 | Mathlib.Data.NNReal.Basic | ∀ (a b : NNReal), (a ≠ b) = (↑a ≠ ↑b) | null | false |
CategoryTheory.CommGrp.forget | Mathlib.CategoryTheory.Monoidal.CommGrp_ | (C : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] → CategoryTheory.Functor (CategoryTheory.CommGrp C) C | The forgetful functor from commutative group objects to the ambient category. | true |
RootPairing.zero_notMem_range_root | Mathlib.LinearAlgebra.RootSystem.Defs | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N) [NeZero 2],
0 ∉ Set.range ⇑P.root | null | true |
ContinuousAffineMap.differentiableOn | Mathlib.Analysis.Calculus.FDeriv.Affine | ∀ {𝕜 : 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 : E →ᴬ[𝕜] F)
{s : Set E}, DifferentiableOn 𝕜 (⇑f) s | null | true |
Mathlib.Tactic.ITauto.Proof.andIntro.inj | Mathlib.Tactic.ITauto | ∀ {ak : Mathlib.Tactic.ITauto.AndKind} {p₁ p₂ : Mathlib.Tactic.ITauto.Proof} {ak_1 : Mathlib.Tactic.ITauto.AndKind}
{p₁_1 p₂_1 : Mathlib.Tactic.ITauto.Proof},
Mathlib.Tactic.ITauto.Proof.andIntro ak p₁ p₂ = Mathlib.Tactic.ITauto.Proof.andIntro ak_1 p₁_1 p₂_1 →
ak = ak_1 ∧ p₁ = p₁_1 ∧ p₂ = p₂_1 | null | true |
_private.Lean.Syntax.0.Lean.Syntax.isQuot._sparseCasesOn_2 | Lean.Syntax | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
ZeroHom.casesOn | Mathlib.Algebra.Group.Hom.Defs | {M : Type u_10} →
{N : Type u_11} →
[inst : Zero M] →
[inst_1 : Zero N] →
{motive : ZeroHom M N → Sort u} →
(t : ZeroHom M N) →
((toFun : M → N) → (map_zero' : toFun 0 = 0) → motive { toFun := toFun, map_zero' := map_zero' }) → motive t | null | false |
FractionalIdeal.isFractional_span_iff | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
{s : Set P}, IsFractional S (Submodule.span R s) ↔ ∃ a ∈ S, ∀ b ∈ s, IsLocalization.IsInteger R (a • b) | null | true |
IsometricContinuousFunctionalCalculus.casesOn | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Isometric | {R : Type u_1} →
{A : Type u_2} →
{p : A → Prop} →
[inst : CommSemiring R] →
[inst_1 : StarRing R] →
[inst_2 : MetricSpace R] →
[inst_3 : IsTopologicalSemiring R] →
[inst_4 : ContinuousStar R] →
[inst_5 : Ring A] →
[inst_6 : StarR... | null | false |
CategoryTheory.Limits.FormalCoproduct.ι_comp_coproductIsoCofanPt | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {𝒜 : Type w} {f : 𝒜 → CategoryTheory.Limits.FormalCoproduct C}
(i : 𝒜),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Sigma.ι f i)
(CategoryTheory.Limits.FormalCoproduct.coproductIsoCofanPt 𝒜 f).hom =
(CategoryTheory.Limits.FormalCop... | null | true |
LinearMap.coe_toContinuousLinearMap | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u} [hnorm : NontriviallyNormedField 𝕜] {E : Type v} [inst : AddCommGroup E] [inst_1 : Module 𝕜 E]
[inst_2 : TopologicalSpace E] [inst_3 : IsTopologicalAddGroup E] [inst_4 : ContinuousSMul 𝕜 E] {F' : Type x}
[inst_5 : AddCommGroup F'] [inst_6 : Module 𝕜 F'] [inst_7 : TopologicalSpace F'] [inst_8 : I... | null | true |
Lean.Parser.longestMatchFnAux | Lean.Parser.Basic | Option Lean.Syntax → ℕ → ℕ → String.Pos.Raw → ℕ → List (Lean.Parser.Parser × ℕ) → Lean.Parser.ParserFn | null | true |
ENNReal.add_ne_top | Mathlib.Data.ENNReal.Operations | ∀ {a b : ENNReal}, a + b ≠ ⊤ ↔ a ≠ ⊤ ∧ b ≠ ⊤ | null | true |
_private.Mathlib.Algebra.Group.Submonoid.Saturation.0.Submonoid.mem_saturation_iff.match_1_1 | Mathlib.Algebra.Group.Submonoid.Saturation | ∀ {M : Type u_1} [inst : CommMonoid M] {s : Submonoid M} {x : M} (motive : (∃ y, x * y ∈ s) → Prop)
(x_1 : ∃ y, x * y ∈ s), (∀ (y : M) (hxy : x * y ∈ s), motive ⋯) → motive x_1 | null | false |
CategoryTheory.Classifier.SubobjectRepresentableBy.isTerminalΩ₀ | Mathlib.CategoryTheory.Subobject.Classifier.Defs | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasPullbacks C] →
{Ω : C} →
(h : CategoryTheory.SubobjectRepresentableBy Ω) →
CategoryTheory.Limits.IsTerminal (CategoryTheory.Subobject.underlying.obj h.Ω₀) | **Alias** of `CategoryTheory.SubobjectRepresentableBy.isTerminalΩ₀`.
---
The main non-trivial result: `h.Ω₀` is actually a terminal object. | true |
Int.emod_zero | Init.Data.Int.DivMod.Bootstrap | ∀ (a : ℤ), a % 0 = a | null | true |
MeasureTheory.tendsto_measure_of_null_frontier | Mathlib.MeasureTheory.Measure.Portmanteau | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] [inst_1 : TopologicalSpace Ω] [OpensMeasurableSpace Ω] {ι : Type u_2}
{L : Filter ι} {μ : MeasureTheory.Measure Ω} {μs : ι → MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure μ]
[∀ (i : ι), MeasureTheory.IsProbabilityMeasure (μs i)],
(∀ (G : Set Ω), IsOpen G ... | One implication of the portmanteau theorem:
For a sequence of Borel probability measures, if the liminf of the measures of any open set is at
least the measure of the open set under a candidate limit measure, then for any set whose
boundary carries no probability mass under the candidate limit measure, then its measure... | true |
RingEquiv.map_sum | Mathlib.Algebra.BigOperators.RingEquiv | ∀ {α : Type u_1} {R : Type u_2} {S : Type u_3} [inst : NonUnitalNonAssocSemiring R]
[inst_1 : NonUnitalNonAssocSemiring S] (g : R ≃+* S) (f : α → R) (s : Finset α), g (∑ x ∈ s, f x) = ∑ x ∈ s, g (f x) | null | true |
Polynomial.Splits.eval_derivative | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : CommRing R] {f : Polynomial R} [inst_1 : IsDomain R] [inst_2 : DecidableEq R],
f.Splits →
∀ (x : R),
Polynomial.eval x (Polynomial.derivative f) =
f.leadingCoeff *
(Multiset.map (fun a => (Multiset.map (fun x_1 => x - x_1) (f.roots.erase a)).prod) f.roots).sum | null | true |
Aesop.Goal.lastExpandedInIteration | Aesop.Tree.Data | Aesop.Goal → Aesop.Iteration | null | true |
Equiv.Perm.disjoint_of_disjoint_support | Mathlib.GroupTheory.Perm.Finite | ∀ {α : Type u} [inst : DecidableEq α] [inst_1 : Fintype α] {H K : Subgroup (Equiv.Perm α)},
(∀ a ∈ H, ∀ b ∈ K, Disjoint a.support b.support) → Disjoint H K | null | true |
Std.TreeMap.Raw.mem_toList_iff_getElem?_eq_some._simp_1 | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp]
[Std.LawfulEqCmp cmp], t.WF → ∀ {k : α} {v : β}, ((k, v) ∈ t.toList) = (t[k]? = some v) | null | false |
CategoryTheory.Limits.MultispanIndex.SymmStruct.noConfusionType | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{ι : Type w} →
{I : CategoryTheory.Limits.MultispanIndex (CategoryTheory.Limits.MultispanShape.prod ι) C} →
I.SymmStruct →
{C' : Type u} →
[inst' : CategoryTheory.Category.{v, u} C'] →
... | null | false |
CochainComplex.Lifting.cocycle₁._proof_5 | Mathlib.Algebra.Homology.ModelCategory.Lifting | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
{A B X Y : CochainComplex C ℤ} {t : A ⟶ X} {i : A ⟶ B} {p : X ⟶ Y} {b : B ⟶ Y} (sq : CategoryTheory.CommSq t i p b)
(hsq : (n : ℤ) → ⋯.LiftStruct) {Q : CochainComplex C ℤ} {π : B ⟶ Q} {hπ : CategoryTheory.CategoryStru... | null | false |
CategoryTheory.Quiv.comp_eq_comp | Mathlib.CategoryTheory.Category.Quiv | ∀ {X Y Z : CategoryTheory.Quiv} (F : X ⟶ Y) (G : Y ⟶ Z), CategoryTheory.CategoryStruct.comp F G = F ⋙q G | Composition in the category of quivers equals prefunctor composition. | true |
_private.Mathlib.Analysis.Complex.JensenFormula.0.AnalyticOnNhd.sum_divisor_le._simp_1_10 | Mathlib.Analysis.Complex.JensenFormula | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, (y ∈ Metric.closedBall x ε) = (dist y x ≤ ε) | null | false |
ZMod.ringHom_map_cast | Mathlib.Data.ZMod.Basic | ∀ {n : ℕ} {R : Type u_1} [inst : NonAssocRing R] (f : R →+* ZMod n) (k : ZMod n), f k.cast = k | null | true |
Setoid.completeLattice._proof_4 | Mathlib.Data.Setoid.Basic | ∀ {α : Type u_1} (x x_1 x_2 : Setoid α), x ≤ x_1 → x ≤ x_2 → ∀ (x_3 x_4 : α), x x_3 x_4 → x_1 x_3 x_4 ∧ x_2 x_3 x_4 | null | false |
Finsupp.lattice._proof_5 | Mathlib.Order.Preorder.Finsupp | ∀ {ι : Type u_1} {M : Type u_2} [inst : Zero M] [inst_1 : Lattice M] (a b : ι →₀ M), SemilatticeInf.inf a b ≤ b | null | false |
List.orderedInsert._unsafe_rec | Mathlib.Data.List.Sort | {α : Type u_1} → (r : α → α → Prop) → [DecidableRel r] → α → List α → List α | null | false |
_private.Mathlib.CategoryTheory.Sites.Sieves.0.CategoryTheory.Presieve.uncurry_bind._simp_1_2 | Mathlib.CategoryTheory.Sites.Sieves | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y | null | false |
AffineAddMonoid.dim | Mathlib.Algebra.AffineMonoid.Embedding | (M : Type u_1) → [AddCancelCommMonoid M] → ℕ | The dimension of an affine monoid `M`, namely the minimum `n` for which `M` embeds into `ℤⁿ`. | true |
TopRep.ctorIdx | Mathlib.RepresentationTheory.Continuous.TopRep | {k : Type u} →
{G : Type v} →
{inst : TopologicalSpace k} →
{inst_1 : Ring k} → {inst_2 : IsTopologicalRing k} → {inst_3 : Monoid G} → TopRep k G → ℕ | null | false |
Lean.Elab.Tactic.iterateExactly'._unsafe_rec | Mathlib.Tactic.Core | {m : Type → Type u} → [Monad m] → ℕ → m Unit → m Unit | null | false |
Filter.HasBasis.comap | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {l : Filter α} {p : ι → Prop} {s : ι → Set α} (f : β → α),
l.HasBasis p s → (Filter.comap f l).HasBasis p fun i => f ⁻¹' s i | null | true |
PresheafOfModules.hasColimitsOfSize | Mathlib.Algebra.Category.ModuleCat.Presheaf.Colimits | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (R : CategoryTheory.Functor Cᵒᵖ RingCat)
[CategoryTheory.Limits.HasColimitsOfSize.{v₂, u₂, v, v + 1} AddCommGrpCat],
CategoryTheory.Limits.HasColimitsOfSize.{v₂, u₂, max u₁ v, max (max (max (v + 1) u) u₁) v₁} (PresheafOfModules R) | null | true |
_private.Mathlib.Data.Stream.Init.0.Stream'.mem_append_stream_right.match_1_1 | Mathlib.Data.Stream.Init | ∀ {α : Type u_1} (motive : (x : α) → List α → (x_2 : Stream' α) → x ∈ x_2 → Prop) (x : α) (x_1 : List α)
(x_2 : Stream' α) (x_3 : x ∈ x_2),
(∀ (x : α) (x_4 : Stream' α) (h : x ∈ x_4), motive x [] x_4 h) →
(∀ (a head : α) (l : List α) (s : Stream' α) (h : a ∈ s), motive a (head :: l) s h) → motive x x_1 x_2 x_3 | null | false |
_private.Mathlib.Analysis.Convex.StrictCombination.0.StrictConvex.centerMass_mem_interior._proof_1_7 | Mathlib.Analysis.Convex.StrictCombination | ∀ {R : Type u_2} {V : Type u_1} {ι : Type u_3} [inst : Field R] [inst_1 : LinearOrder R] [inst_2 : TopologicalSpace V]
[inst_3 : AddCommGroup V] [inst_4 : Module R V] {s : Set V} {w : ι → R} {z : ι → V} (i : ι) (t : Finset ι),
((∀ i ∈ t, 0 ≤ w i) →
∀ (i j : ι), i ∈ t → j ∈ t → z i ≠ z j → w i ≠ 0 → w j ≠ 0 → ... | null | false |
AddMonoidHom.mkRingHomOfMulSelfOfTwoNeZero._proof_4 | Mathlib.Algebra.Ring.Hom.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : CommRing α] [inst_1 : CommRing β] (f : β →+ α) (x y : β),
(↑f).toFun (x + y) = (↑f).toFun x + (↑f).toFun y | null | false |
instUniqueSumsFinsupp | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ {ι : Type u_1} {G : Type u_2} [inst : AddZeroClass G] [UniqueSums G], UniqueSums (ι →₀ G) | null | true |
Std.ExtTreeSet.contains_iff_mem | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k : α},
t.contains k = true ↔ k ∈ t | null | true |
Lean.Environment.const2ModIdx | Lean.Environment | Lean.Environment → Std.HashMap Lean.Name Lean.ModuleIdx | Mapping from constant name to module (index) where constant has been declared.
Recall that a Lean file has a header where previously compiled modules can be imported.
Each imported module has a unique `ModuleIdx`.
Many extensions use the `ModuleIdx` to efficiently retrieve information stored in imported modules.
Remar... | true |
Int.floor_eq_self_iff_mem | Mathlib.Algebra.Order.Floor.Ring | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : LinearOrder R] [inst_2 : FloorRing R] [IsOrderedRing R] (a : R),
↑⌊a⌋ = a ↔ a ∈ Set.range Int.cast | null | true |
Std.TreeSet.getD_inter_of_not_mem_right | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeSet α cmp} [Std.TransCmp cmp] {k fallback : α},
k ∉ t₂ → (t₁ ∩ t₂).getD k fallback = fallback | null | true |
CommRingCat.Colimits.Prequotient.add.elim | Mathlib.Algebra.Category.Ring.Colimits | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
{F : CategoryTheory.Functor J CommRingCat} →
{motive : CommRingCat.Colimits.Prequotient F → Sort u} →
(t : CommRingCat.Colimits.Prequotient F) →
t.ctorIdx = 4 → ((a a_1 : CommRingCat.Colimits.Prequotient F) → motive (a.add a_1)) → mo... | null | false |
Affine.Simplex.disjoint_interior_closedInterior_faceOpposite | Mathlib.LinearAlgebra.AffineSpace.Simplex.Basic | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] [inst_4 : PartialOrder k] [Nontrivial k] [ZeroLEOneClass k] {n : ℕ} [inst_7 : NeZero n]
(s : Affine.Simplex k P n) (i : Fin (n + 1)), Disjoint s.interior (s.faceOpposite i).closedI... | null | true |
_private.Lean.DocString.Add.0.Lean.addDocString'.match_1 | Lean.DocString.Add | (motive : Option (Lean.TSyntax `Lean.Parser.Command.docComment) → Sort u_1) →
(docString? : Option (Lean.TSyntax `Lean.Parser.Command.docComment)) →
((docString : Lean.TSyntax `Lean.Parser.Command.docComment) → motive (some docString)) →
(Unit → motive none) → motive docString? | null | false |
_private.Init.Data.Array.Lemmas.0.Array.map_eq_append_iff._simp_1_2 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {xs : Array α} {ys zs : Array β} {f : α → Option β},
(Array.filterMap f xs = ys ++ zs) = ∃ as bs, xs = as ++ bs ∧ Array.filterMap f as = ys ∧ Array.filterMap f bs = zs | null | false |
Algebra.tensorH1CotangentOfIsLocalization._proof_3 | Mathlib.RingTheory.Etale.Kaehler | ∀ (R : Type u_2) {S : Type u_3} (T : Type u_1) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T]
[inst_3 : Algebra R S] [inst_4 : Algebra R T] [inst_5 : Algebra S T] [inst_6 : IsScalarTower R S T] (M : Submonoid S)
[IsLocalization M T] (y : (Algebra.Generators.self R S).toExtension.Ring)
(hy : y ∈ S... | null | false |
AlgebraicGeometry.isLocalizing_pushforward_of_isLocalizing | Mathlib.AlgebraicGeometry.Modules.Tilde | ∀ {R S : CommRingCat} (φ : R ⟶ S) {M : (AlgebraicGeometry.Spec S).Modules},
AlgebraicGeometry.IsLocalizing (AlgebraicGeometry.modulesSpecToSheaf.obj M) →
AlgebraicGeometry.IsLocalizing
(AlgebraicGeometry.modulesSpecToSheaf.obj
((AlgebraicGeometry.Scheme.Modules.pushforward (AlgebraicGeometry.Spec.ma... | null | true |
Polynomial.trailingDegree_le_of_ne_zero | Mathlib.Algebra.Polynomial.Degree.TrailingDegree | ∀ {R : Type u} {n : ℕ} [inst : Semiring R] {p : Polynomial R}, p.coeff n ≠ 0 → p.trailingDegree ≤ ↑n | null | true |
Int32.and_assoc | Init.Data.SInt.Bitwise | ∀ (a b c : Int32), a &&& b &&& c = a &&& (b &&& c) | null | true |
NonUnitalRingHom.copy | Mathlib.Algebra.Ring.Hom.Defs | {α : Type u_2} →
{β : Type u_3} →
[inst : NonUnitalNonAssocSemiring α] →
[inst_1 : NonUnitalNonAssocSemiring β] → (f : α →ₙ+* β) → (f' : α → β) → f' = ⇑f → α →ₙ+* β | Copy of a `RingHom` with a new `toFun` equal to the old one. Useful to fix definitional
equalities. | true |
Nat.card_units | Mathlib.Algebra.GroupWithZero.Units.Fintype | ∀ (α : Type u_1) [inst : GroupWithZero α], Nat.card αˣ = Nat.card α - 1 | null | true |
Set.wellFoundedOn_empty | Mathlib.Order.WellFoundedSet | ∀ {α : Type u_2} (r : α → α → Prop), ∅.WellFoundedOn r | null | true |
IsAdjoinRoot.adjoinRootAlgEquiv._proof_1 | Mathlib.RingTheory.IsAdjoinRoot | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : Ring S] [inst_2 : Algebra R S],
RingHomClass (Polynomial R →ₐ[R] S) (Polynomial R) S | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.