name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.size_left_le_size_union._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.QExpansion.0.aux_IsBigO_mul | Mathlib.NumberTheory.ModularForms.EisensteinSeries.QExpansion | ∀ (k l : ℕ) (p : ℝ) {f : ℕ → ℂ},
(f =O[Filter.atTop] fun n => ↑n ^ l) →
(fun n => f n * (2 * ↑Real.pi * Complex.I * ↑n / ↑p) ^ k) =O[Filter.atTop] fun n => ↑(n ^ (l + k)) | null | true |
ProbabilityTheory.Kernel.compProd_prodMkLeft_eq_comp | Mathlib.Probability.Kernel.Composition.KernelLemmas | ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} {mX : MeasurableSpace X} {mY : MeasurableSpace Y}
{mZ : MeasurableSpace Z} (κ : ProbabilityTheory.Kernel X Y) [ProbabilityTheory.IsSFiniteKernel κ]
(η : ProbabilityTheory.Kernel Y Z) [ProbabilityTheory.IsSFiniteKernel η],
κ.compProd (ProbabilityTheory.Kernel.prodMkLe... | null | true |
ENNReal.tendsto_nat_tsum | Mathlib.Topology.Algebra.InfiniteSum.ENNReal | ∀ (f : ℕ → ENNReal), Filter.Tendsto (fun n => ∑ i ∈ Finset.range n, f i) Filter.atTop (nhds (∑' (n : ℕ), f n)) | null | true |
MonadSatisfying.instStateRefT'._proof_2 | BatteriesRecycling.MonadSatisfying.Basic | ∀ {m : Type → Type} {ω σ : Type} [inst : Monad m] [LawfulMonad m], LawfulFunctor (StateRefT' ω σ m) | null | false |
BEq.rfl | Init.Core | ∀ {α : Type u_1} [inst : BEq α] [ReflBEq α] {a : α}, (a == a) = true | null | true |
IsLUB | Mathlib.Order.Bounds.Defs | {α : Type u_1} → [LE α] → Set α → α → Prop | `a` is a least upper bound of a set `s`; for a partial order, it is unique if exists. | true |
Std.DTreeMap.Internal.Impl.getKey_insertMany!_list_of_mem | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF →
∀ {l : List ((a : α) × β a)} {k k' : α},
compare k k' = Ordering.eq →
List.Pairwise (fun a b => ¬compare a.fst b.fst = Ordering.eq) l →
k ∈ List.map Sigma.fst l →
∀ {... | null | true |
Std.Do.Spec.seq' | Std.Do.Triple.SpecLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} {P : Std.Do.Assertion ps} [inst : Monad m]
[inst_1 : Std.Do.WPMonad m ps] {α β : Type u} {x : m (α → β)} {y : m α} {Q : Std.Do.PostCond β ps},
⦃P⦄ x ⦃(fun f => (Std.Do.wp y).apply (fun a => Q.1 (f a), Q.2), Q.2)⦄ → ⦃P⦄ (x <*> y) ⦃Q⦄ | null | true |
Lean.MetavarContext.getDelayedMVarAssignmentCore? | Lean.MetavarContext | Lean.MetavarContext → Lean.MVarId → Option Lean.DelayedMetavarAssignment | null | true |
Std.DTreeMap.mem_of_mem_insert | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp] {k a : α}
{v : β k}, a ∈ t.insert k v → cmp k a ≠ Ordering.eq → a ∈ t | null | true |
MvPowerSeries.rescaleMonoidHom._proof_1 | Mathlib.RingTheory.MvPowerSeries.Substitution | ∀ {σ : Type u_1} {R : Type u_2} [inst : CommSemiring R] (a b : σ → R),
MvPowerSeries.rescale (a * b) = MvPowerSeries.rescale a * MvPowerSeries.rescale b | null | false |
_private.Lean.Meta.CongrTheorems.0.Lean.Meta.mkCongrSimpCore?.mkProof.go._unsafe_rec | Lean.Meta.CongrTheorems | Array Lean.Meta.CongrArgKind → ℕ → Lean.Expr → Lean.MetaM Lean.Expr | null | false |
MeasureTheory.ennrealPreVariation.congr_simp | Mathlib.MeasureTheory.Measure.PreVariation | ∀ {X : Type u_1} [inst : MeasurableSpace X] (f f_1 : Set X → ENNReal) (e_f : f = f_1)
(hf : MeasureTheory.IsSigmaSubadditiveSetFun f) (hf' : f ∅ = 0),
MeasureTheory.ennrealPreVariation f hf hf' = MeasureTheory.ennrealPreVariation f_1 ⋯ ⋯ | null | true |
_private.Init.Data.Int.Linear.0.Int.Linear.poly_eq_zero_eq_false | Init.Data.Int.Linear | ∀ (ctx : Int.Linear.Context) {p : Int.Linear.Poly} {k : ℤ},
Int.Linear.Poly.divCoeffs k p = true →
k > 0 → Int.Linear.cmod p.getConst k < 0 → (Int.Linear.Poly.denote ctx p = 0) = False | null | true |
_private.Mathlib.Analysis.ODE.ExistUnique.0.ODE_solution_unique_univ._proof_1_2 | Mathlib.Analysis.ODE.ExistUnique | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E], ContinuousSMul ℝ E | null | false |
integral_sin_pow_aux | Mathlib.Analysis.SpecialFunctions.Integrals.Basic | ∀ {a b : ℝ} (n : ℕ),
∫ (x : ℝ) in a..b, Real.sin x ^ (n + 2) =
(Real.sin a ^ (n + 1) * Real.cos a - Real.sin b ^ (n + 1) * Real.cos b +
(↑n + 1) * ∫ (x : ℝ) in a..b, Real.sin x ^ n) -
(↑n + 1) * ∫ (x : ℝ) in a..b, Real.sin x ^ (n + 2) | null | true |
Multiset.instDistribLattice | Mathlib.Data.Multiset.UnionInter | {α : Type u_1} → [DecidableEq α] → DistribLattice (Multiset α) | null | true |
_private.Mathlib.RingTheory.AdjoinRoot.0.AdjoinRoot.map._simp_1 | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u} {S : Type v} {T : Type w} [inst : Semiring R] {p : Polynomial R} [inst_1 : Semiring S] (f : R →+* S)
[inst_2 : Semiring T] (g : S →+* T) (x : T),
Polynomial.eval₂ (g.comp f) x p = Polynomial.eval₂ g x (Polynomial.map f p) | null | false |
thickenedIndicator.congr_simp | Mathlib.Topology.MetricSpace.ThickenedIndicator | ∀ {α : Type u_1} [inst : PseudoEMetricSpace α] {δ δ_1 : ℝ} (e_δ : δ = δ_1) (δ_pos : 0 < δ) (E E_1 : Set α),
E = E_1 → thickenedIndicator δ_pos E = thickenedIndicator ⋯ E_1 | null | true |
ENat.smul_sSup | Mathlib.Data.ENat.Lattice | ∀ {R : Type u_4} [inst : SMul R ℕ∞] [IsScalarTower R ℕ∞ ℕ∞] (s : Set ℕ∞) (c : R), c • sSup s = ⨆ a ∈ s, c • a | null | true |
Preorder.piCongrLeft_comp_restrictLe | Mathlib.Order.Restriction | ∀ {α : Type u_1} [inst : Preorder α] {π : α → Type u_2} [inst_1 : LocallyFiniteOrderBot α] {a : α},
⇑(Equiv.piCongrLeft (fun i => π ↑i) (Equiv.IicFinsetSet a).symm) ∘ Preorder.restrictLe a = Preorder.frestrictLe a | null | true |
Representation.Coinvariants.mk_tmul_inv | Mathlib.RepresentationTheory.Coinvariants | ∀ {k : Type u_6} {G : Type u_7} {V : Type u_8} {W : Type u_9} [inst : CommRing k] [inst_1 : Group G]
[inst_2 : AddCommGroup V] [inst_3 : Module k V] [inst_4 : AddCommGroup W] [inst_5 : Module k W]
(ρ : Representation k G V) (τ : Representation k G W) (x : V) (y : W) (g : G),
(Representation.Coinvariants.mk (ρ.tpr... | null | true |
CategoryTheory.ParametrizedAdjunction.preservesLimit_flip_obj | Mathlib.CategoryTheory.Adjunction.ParametrizedLimits | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] [inst_2 : CategoryTheory.Category.{v_3, u_3} C₃]
{F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)}
{G : CategoryTheory.Functor C₁ᵒᵖ (CategoryTheory.Functor... | null | true |
Part.get_eq_get_of_eq | Mathlib.Data.Part | ∀ {α : Type u_1} (a : Part α) (ha : a.Dom) {b : Part α} (h : a = b), a.get ha = b.get ⋯ | null | true |
Finpartition.ofErase.congr_simp | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : OrderBot α] [inst_2 : DecidableEq α] {a : α} (parts parts_1 : Finset α)
(e_parts : parts = parts_1) (sup_indep : parts.SupIndep id) (sup_parts : parts.sup id = a),
Finpartition.ofErase parts sup_indep sup_parts = Finpartition.ofErase parts_1 ⋯ ⋯ | null | true |
_private.Lean.Elab.Import.0.Lean.Elab.printImports.match_1 | Lean.Elab.Import | (motive : Array Lean.Import × Lean.Position × Lean.MessageLog → Sort u_1) →
(x : Array Lean.Import × Lean.Position × Lean.MessageLog) →
((deps : Array Lean.Import) → (fst : Lean.Position) → (snd : Lean.MessageLog) → motive (deps, fst, snd)) → motive x | null | false |
CategoryTheory.Arrow.leftFunc_obj | Mathlib.CategoryTheory.Comma.Arrow | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
(X : CategoryTheory.Comma (CategoryTheory.Functor.id C) (CategoryTheory.Functor.id C)),
CategoryTheory.Arrow.leftFunc.obj X = X.left | null | true |
ClassGroup.mk._proof_1 | Mathlib.RingTheory.ClassGroup.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R], (toPrincipalIdeal R (FractionRing R)).range.Normal | null | false |
NonarchimedeanGroup.mk._flat_ctor | Mathlib.Topology.Algebra.Nonarchimedean.Basic | ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G],
(Continuous fun p => p.1 * p.2) → (Continuous fun a => a⁻¹) → (∀ U ∈ nhds 1, ∃ V, ↑V ⊆ U) → NonarchimedeanGroup G | null | false |
String.Slice.Pattern.Model.ForwardStringSearcher.isLongestRevMatch_iff | Init.Data.String.Lemmas.Pattern.String.Basic | ∀ {pat : String} {s : String.Slice} {pos : s.Pos},
String.Slice.Pattern.Model.IsLongestRevMatch pat pos ↔ (s.sliceFrom pos).copy = pat | null | true |
Filter.Realizer.ofEquiv_F | Mathlib.Data.Analysis.Filter | ∀ {α : Type u_1} {τ : Type u_4} {f : Filter α} (F : f.Realizer) (E : F.σ ≃ τ) (s : τ),
(F.ofEquiv E).F.f s = F.F.f (E.symm s) | null | true |
Lean.Name.hasMacroScopes._unsafe_rec | Init.Prelude | Lean.Name → Bool | null | false |
Lean.Diff.Action.skip | Lean.Util.Diff | Lean.Diff.Action | Leave the item in the source | true |
_private.Mathlib.AlgebraicTopology.ExtraDegeneracy.0.CategoryTheory.SimplicialObject.Augmented.ExtraDegeneracy.homotopy._proof_33 | Mathlib.AlgebraicTopology.ExtraDegeneracy | ∀ {n : ℕ} (j k : Fin (n + 1)), j.rev = k → ↑k = ↑j.succ.rev | null | false |
_private.Mathlib.Tactic.ClickSuggestions.TryPremises.0.Mathlib.Tactic.ClickSuggestions.Candidates.grw.noConfusion | Mathlib.Tactic.ClickSuggestions.TryPremises | {P : Sort u} →
{i : Mathlib.Tactic.ClickSuggestions.GrwInfo} →
{arr : Array Mathlib.Tactic.ClickSuggestions.GrwLemma} →
{i' : Mathlib.Tactic.ClickSuggestions.GrwInfo} →
{arr' : Array Mathlib.Tactic.ClickSuggestions.GrwLemma} →
Mathlib.Tactic.ClickSuggestions.Candidates.grw✝ i arr =
... | null | false |
CategoryTheory.GrothendieckTopology.PreservesSheafification.transport | Mathlib.CategoryTheory.Sites.Equivalence | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] (K : CategoryTheory.GrothendieckTopology D)
(G : CategoryTheory.Functor D C) {A : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} A] (B : Type u₄)
... | null | true |
CategoryTheory.RanIsSheafOfIsCocontinuous.liftAux._proof_1 | Mathlib.CategoryTheory.Sites.CoverLifting | ∀ {C : Type u_1} {D : Type u_4} [inst : CategoryTheory.Category.{u_2, u_1} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] {G : CategoryTheory.Functor C D}
{J : CategoryTheory.GrothendieckTopology C} {K : CategoryTheory.GrothendieckTopology D} [G.IsCocontinuous J K] {X : D}
{S : K.Cover X} {Y : C} (f : G.obj Y... | null | false |
IntermediateField.lift_relrank_comap_comap_eq_lift_relrank_of_surjective | Mathlib.FieldTheory.Relrank | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {L : Type w} [inst_3 : Field L]
[inst_4 : Algebra F L] (A B : IntermediateField F E) (f : L →ₐ[F] E),
Function.Surjective ⇑f →
Cardinal.lift.{v, w} ((IntermediateField.comap f A).relrank (IntermediateField.comap f B)) =
... | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.ofNat_sub_ofNat_of_le._proof_1_1 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x y : ℕ), y < 2 ^ w → y ≤ x → ¬2 ^ w - y + x = 2 ^ w + (x - y) → False | null | false |
_private.Mathlib.Data.Set.Image.0.Set.imageFactorization_surjective.match_1_1 | Mathlib.Data.Set.Image | ∀ {α : Type u_2} {β : Type u_1} {f : α → β} {s : Set α} (motive : ↑(f '' s) → Prop) (x : ↑(f '' s)),
(∀ (a : α) (ha : a ∈ s), motive ⟨f a, ⋯⟩) → motive x | null | false |
instMinInt16 | Init.Data.SInt.Basic | Min Int16 | null | true |
iSup_inf_eq | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u} {ι : Sort w} [inst : Order.Frame α] (f : ι → α) (a : α), (⨆ i, f i) ⊓ a = ⨆ i, f i ⊓ a | null | true |
MeasureTheory.OuterMeasure.instLawfulFunctor | Mathlib.MeasureTheory.OuterMeasure.Operations | LawfulFunctor MeasureTheory.OuterMeasure | null | true |
Lean.Parser.Term.throwNamedErrorMacro | Lean.Parser.Term | Lean.Parser.Parser | Throws an error exception, tagging the associated message as a named error with the specified name
and validating that an associated error explanation exists. The message may be passed as an
interpolated string or a `MessageData` term. The result of `getRef` is used as position information.
| true |
QuaternionAlgebra.coe_natCast | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} {c₁ c₂ c₃ : R} [inst : AddCommGroupWithOne R] (n : ℕ), ↑↑n = ↑n | null | true |
CategoryTheory.IndParallelPairPresentation.parallelPairIsoParallelPairCompYoneda._proof_4 | Mathlib.CategoryTheory.Limits.Indization.ParallelPair | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {A B : CategoryTheory.Functor Cᵒᵖ (Type u_1)}
{f g : A ⟶ B} (P : CategoryTheory.IndParallelPairPresentation f g),
CategoryTheory.Limits.HasColimit
(((CategoryTheory.Functor.whiskeringRight P.I C (CategoryTheory.Functor Cᵒᵖ (Type u_1))).obj
... | null | false |
Std.Sat.AIG.RefVec.MapTarget.recOn | Std.Sat.AIG.RefVecOperator.Map | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{len : ℕ} →
{motive : Std.Sat.AIG.RefVec.MapTarget aig len → Sort u} →
(t : Std.Sat.AIG.RefVec.MapTarget aig len) →
((vec : aig.RefVec len) →
(func : (aig : Std... | null | false |
NonemptyFinLinOrd.hom_hom_ofHom | Mathlib.Order.Category.NonemptyFinLinOrd | ∀ {X Y : Type u} [inst : Nonempty X] [inst_1 : LinearOrder X] [inst_2 : Fintype X] [inst_3 : Nonempty Y]
[inst_4 : LinearOrder Y] [inst_5 : Fintype Y] (f : X →o Y), LinOrd.Hom.hom (NonemptyFinLinOrd.ofHom f).hom = f | null | true |
Std.Async.BaseAsync.instMonad | Std.Async.Basic | Monad Std.Async.BaseAsync | null | true |
ProbabilityTheory.condCDF | Mathlib.Probability.Kernel.Disintegration.CondCDF | {α : Type u_1} → {mα : MeasurableSpace α} → MeasureTheory.Measure (α × ℝ) → α → StieltjesFunction ℝ | Conditional cdf of the measure given the value on `α`, as a Stieltjes function. | true |
Std.DTreeMap.Internal.Impl.getKeyD_union!_of_contains_eq_false_left | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
m₁.WF →
m₂.WF →
∀ {k fallback : α},
Std.DTreeMap.Internal.Impl.contains k m₁ = false → (m₁.union! m₂).getKeyD k fallback = m₂.getKeyD k fallback | null | true |
Sat.Fmla.reify.mk | Mathlib.Tactic.Sat.FromLRAT | ∀ {v : Sat.Valuation} {f : Sat.Fmla} {p : Prop}, (¬v.satisfies_fmla f → p) → Sat.Fmla.reify v f p | null | true |
Std.ExtHashMap.ext_getKey_getElem?_iff | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
{m₁ m₂ : Std.ExtHashMap α β},
m₁ = m₂ ↔ (∀ (k : α) (hk : k ∈ m₁) (hk' : k ∈ m₂), m₁.getKey k hk = m₂.getKey k hk') ∧ ∀ (k : α), m₁[k]? = m₂[k]? | null | true |
ExceptCpsT.runCatch | Init.Control.ExceptCps | {m : Type u_1 → Type u_2} → {α : Type u_1} → [Monad m] → ExceptCpsT α m α → m α | Returns the value of a computation, forgetting whether it was an exception or a success.
This corresponds to early return.
| true |
CategoryTheory.Limits.spanCompIso._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (F : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z)
{X_1 Y_1 : CategoryTheory.Limits.WalkingSpan} (f_1 : X_1 ⟶ Y_1),
CategoryTheory.CategoryStruct.comp (((CategoryTheory.L... | null | false |
Lean.Elab.TerminationMeasure.mk.noConfusion | Lean.Elab.PreDefinition.TerminationMeasure | {P : Sort u} →
{ref : Lean.Syntax} →
{structural : Bool} →
{fn : Lean.Expr} →
{ref' : Lean.Syntax} →
{structural' : Bool} →
{fn' : Lean.Expr} →
{ ref := ref, structural := structural, fn := fn } =
{ ref := ref', structural := structural', fn := f... | null | false |
_private.Lean.Widget.Diff.0.Lean.Widget.ExprDiff.mk.injEq | Lean.Widget.Diff | ∀ (changesBefore changesAfter changesBefore_1 changesAfter_1 : Lean.SubExpr.PosMap Lean.Widget.ExprDiffTag✝),
({ changesBefore := changesBefore, changesAfter := changesAfter } =
{ changesBefore := changesBefore_1, changesAfter := changesAfter_1 }) =
(changesBefore = changesBefore_1 ∧ changesAfter = changesA... | null | true |
NumberField.instCommRingInfiniteAdeleRing | Mathlib.NumberTheory.NumberField.InfiniteAdeleRing | (K : Type u_1) → [inst : Field K] → CommRing (NumberField.InfiniteAdeleRing K) | null | true |
Lean.Elab.MonadParentDecl.noConfusionType | Lean.Elab.InfoTree.Types | Sort u → {m : Type → Type} → Lean.Elab.MonadParentDecl m → {m' : Type → Type} → Lean.Elab.MonadParentDecl m' → Sort u | null | false |
Equivalence.of_isEquiv | Mathlib.Order.Defs.Unbundled | ∀ {α : Sort u_1} (lt : α → α → Prop) [IsEquiv α lt], Equivalence lt | null | true |
CategoryTheory.Abelian.Ext.bilinearComp | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
[inst_2 : CategoryTheory.HasExt C] →
(X Y Z : C) →
(a b c : ℕ) →
a + b = c →
CategoryTheory.Abelian.Ext X Y a →+ CategoryTheory.Abelian.Ext Y Z b →+ CategoryTheory.Abe... | The composition of `Ext`, as a bilinear map. | true |
BialgHom.toAlgHom._proof_2 | Mathlib.RingTheory.Bialgebra.Hom | ∀ {R : Type u_3} {A : Type u_2} {B : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : CoalgebraStruct R A] [inst_6 : CoalgebraStruct R B]
(f : A →ₐc[R] B), f.toLinearMap 0 = 0 | null | false |
Seminorm.instSeminormClass | Mathlib.Analysis.Seminorm | ∀ {𝕜 : Type u_3} {E : Type u_7} [inst : SeminormedRing 𝕜] [inst_1 : AddGroup E] [inst_2 : SMul 𝕜 E],
SeminormClass (Seminorm 𝕜 E) 𝕜 E | null | true |
_private.Lean.Elab.Tactic.Do.Internal.VCGen.RuleCache.0.Lean.Elab.Tactic.Do.Internal.Std.HashMap.getDM.match_1 | Lean.Elab.Tactic.Do.Internal.VCGen.RuleCache | {β : Type (max u_2 (max (max u_3 u_1) u_2) u_1)} →
(motive : Option β → Sort u_4) → (x : Option β) → ((b : β) → motive (some b)) → ((x : Option β) → motive x) → motive x | null | false |
AddCircle.denseRange_zsmul_iff | Mathlib.Topology.Instances.AddCircle.DenseSubgroup | ∀ {p : ℝ} [Fact (0 < p)] {a : AddCircle p}, (DenseRange fun x => x • a) ↔ addOrderOf a = 0 | The multiples of a number `a` are dense on a circle of length `p > 0`
iff `a` has infinite additive order. | true |
Multiset.equivDFinsupp._proof_2 | Mathlib.Data.DFinsupp.Multiset | ∀ {α : Type u_1} [inst : DecidableEq α], Multiset.toDFinsupp.comp DFinsupp.toMultiset = AddMonoidHom.id (Π₀ (x : α), ℕ) | null | false |
Std.HashMap.Raw.getKeyD_inter_of_not_mem_right | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → ∀ {k fallback : α}, k ∉ m₂ → (m₁ ∩ m₂).getKeyD k fallback = fallback | null | true |
_private.Lean.PrettyPrinter.Delaborator.Options.0.Lean.initFn._@.Lean.PrettyPrinter.Delaborator.Options.1488711282._hygCtx._hyg.4 | Lean.PrettyPrinter.Delaborator.Options | IO (Lean.Option Bool) | null | false |
MeasureTheory.LocallyIntegrable.integrable_of_isBigO_atTop_of_norm_isNegInvariant | Mathlib.MeasureTheory.Integral.Asymptotics | ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] {f : α → E} {g : α → F}
[inst_1 : TopologicalSpace α] [SecondCountableTopology α] [inst_3 : MeasurableSpace α] {μ : MeasureTheory.Measure α}
[inst_4 : NormedAddCommGroup F] [inst_5 : AddCommGroup α] [inst_6 : LinearOrder α] [IsOrderedAddMo... | If `f` is locally integrable, `‖f(-x)‖ = ‖f(x)‖`, and `f =O[atTop] g`, for some
`g` integrable at `atTop`, then `f` is integrable. | true |
Representation.norm_self_apply | Mathlib.RepresentationTheory.Basic | ∀ {k : Type u_1} {G : Type u_2} {V : Type u_3} [inst : Semiring k] [inst_1 : Group G] [inst_2 : Fintype G]
[inst_3 : AddCommMonoid V] [inst_4 : Module k V] (ρ : Representation k G V) (g : G) (x : V),
ρ.norm ((ρ g) x) = ρ.norm x | null | true |
WithCStarModule.instUnique | Mathlib.Analysis.CStarAlgebra.Module.Synonym | (A : Type u_3) → (E : Type u_4) → [Unique E] → Unique (WithCStarModule A E) | null | true |
Lean.Meta.Match.State.mk.injEq | Lean.Meta.Match.Match | ∀ (used : Std.HashSet ℕ) (overlaps : Lean.Meta.Match.Overlaps) (counterExamples : Array (List Lean.Meta.Match.Example))
(used_1 : Std.HashSet ℕ) (overlaps_1 : Lean.Meta.Match.Overlaps)
(counterExamples_1 : Array (List Lean.Meta.Match.Example)),
({ used := used, overlaps := overlaps, counterExamples := counterExam... | null | true |
CategoryTheory.Limits.preservesProduct_of_preservesBiproduct | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {D : Type u'}
[inst_2 : CategoryTheory.Category.{v', u'} D] [inst_3 : CategoryTheory.Preadditive D] (F : CategoryTheory.Functor C D)
[inst_4 : F.PreservesZeroMorphisms] {J : Type u_1} [Finite J] {f : J → C}
[CategoryT... | A functor between preadditive categories that preserves (zero morphisms and) finite biproducts
preserves finite products. | true |
CategoryTheory.Lax.OplaxTrans.vCompApp | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G H : CategoryTheory.LaxFunctor B C} →
CategoryTheory.Lax.OplaxTrans F G → CategoryTheory.Lax.OplaxTrans G H → (a : B) → F.obj a ⟶ H.obj a | Auxiliary definition for `vComp`. | true |
TrivSqZeroExt.instL1SeminormedRing._proof_1 | Mathlib.Analysis.Normed.Algebra.TrivSqZeroExt | ∀ {R : Type u_1} {M : Type u_2} [inst : SeminormedRing R] [inst_1 : SeminormedAddCommGroup M] (x y : TrivSqZeroExt R M),
dist x y = ‖-x + y‖ | null | false |
Algebra.adjoin_empty | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ (R : Type uR) (A : Type uA) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A], R[] = ⊥ | null | true |
LinearMap.intrinsicStar_mulRight | Mathlib.Algebra.Star.LinearMap | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : InvolutiveStar R] {E : Type u_6} [inst_2 : NonUnitalNonAssocSemiring E]
[inst_3 : StarRing E] [inst_4 : Module R E] [inst_5 : StarModule R E] [inst_6 : SMulCommClass R E E]
[inst_7 : IsScalarTower R E E] (x : E),
star (WithConv.toConv (LinearMap.mulRight R x)) = With... | null | true |
_private.Mathlib.Combinatorics.Graph.Subgraph.0.Graph.le_iff_compatible_subset_subset.match_1_1 | Mathlib.Combinatorics.Graph.Subgraph | ∀ {α : Type u_1} {β : Type u_2} {G H : Graph α β}
(motive : G.Compatible H ∧ G.vertexSet ⊆ H.vertexSet ∧ G.edgeSet ⊆ H.edgeSet → Prop)
(x : G.Compatible H ∧ G.vertexSet ⊆ H.vertexSet ∧ G.edgeSet ⊆ H.edgeSet),
(∀ (h : G.Compatible H) (hV : G.vertexSet ⊆ H.vertexSet) (hE : G.edgeSet ⊆ H.edgeSet), motive ⋯) → motive... | null | false |
countableSupClosure_eq_self._simp_2 | Mathlib.Order.CountableSupClosed | ∀ {α : Type u_2} {s : Set α} [inst : Preorder α], (countableSupClosure s = s) = CountableSupClosed s | null | false |
Finsupp.prod_of_support_subset | Mathlib.Algebra.BigOperators.Finsupp.Basic | ∀ {α : Type u_1} {M : Type u_8} {N : Type u_10} [inst : Zero M] [inst_1 : CommMonoid N] (f : α →₀ M) {s : Finset α},
f.support ⊆ s → ∀ (g : α → M → N), (∀ i ∈ s, g i 0 = 1) → f.prod g = ∏ x ∈ s, g x (f x) | null | true |
ENat.coe_lt_coe | Mathlib.Data.ENat.Basic | ∀ {n m : ℕ}, ↑n < ↑m ↔ n < m | null | true |
CategoryTheory.CountableAB4Star.of_hasExactLimitsOfShape_nat | Mathlib.CategoryTheory.Abelian.GrothendieckAxioms.Basic | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[CategoryTheory.Limits.HasFiniteBiproducts C] [CategoryTheory.Limits.HasFiniteColimits C]
[inst_4 : CategoryTheory.Limits.HasCountableProducts C]
[CategoryTheory.HasExactLimitsOfShape (CategoryTheory.Discr... | Checking exact limits of shape `Discrete ℕ` is enough for countable AB4\*, provided that the
category has finite biproducts and finite colimits.
| true |
Std.ExtHashMap.getElem?_filter' | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : LawfulBEq α]
{f : α → β → Bool} {k : α}, (Std.ExtHashMap.filter f m)[k]? = Option.filter (f k) m[k]? | Simpler variant of `getElem?_filter` when `LawfulBEq` is available. | true |
Lean.Meta.Grind.propagateEqUp | Lean.Meta.Tactic.Grind.Propagate | Lean.Meta.Grind.Propagator | Propagates `Eq` upwards | true |
_private.Mathlib.Algebra.Homology.Embedding.Basic.0.ComplexShape.instIsTruncGENatIntEmbeddingUpIntGE._proof_1 | Mathlib.Algebra.Homology.Embedding.Basic | ∀ (p : ℤ) {j : ℕ} {x : ℤ}, p + ↑j + 1 = x → p + (↑j + 1) = x | null | false |
Holor.instAddMonoid._aux_3 | Mathlib.Data.Holor | {α : Type} → {ds : List ℕ} → [AddMonoid α] → ℕ → Holor α ds → Holor α ds | null | false |
CochainComplex.mappingCone.mapHomologicalComplexXIso' | Mathlib.Algebra.Homology.HomotopyCategory.MappingCone | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v, u_1} C] →
[inst_1 : CategoryTheory.Category.{v', u_2} D] →
[inst_2 : CategoryTheory.Preadditive C] →
[inst_3 : CategoryTheory.Preadditive D] →
{F G : CochainComplex C ℤ} →
(φ : F ⟶ G) →
... | If `H : C ⥤ D` is an additive functor and `φ` is a morphism of cochain complexes
in `C`, this is the comparison isomorphism (in each degree `n`) between the image
by `H` of `mappingCone φ` and the mapping cone of the image by `H` of `φ`.
It is an auxiliary definition for `mapHomologicalComplexXIso` and
`mapHomologicalC... | true |
Mathlib.Tactic.ClickSuggestions.RwInfo.mk.injEq | Mathlib.Tactic.ClickSuggestions.Rewrite | ∀ (rootExpr subExpr : Lean.Expr) (rflTarget? : Option Lean.Expr) (pos : Lean.SubExpr.Pos)
(rwKind : Mathlib.Tactic.ClickSuggestions.RwKind) (rootExpr_1 subExpr_1 : Lean.Expr) (rflTarget?_1 : Option Lean.Expr)
(pos_1 : Lean.SubExpr.Pos) (rwKind_1 : Mathlib.Tactic.ClickSuggestions.RwKind),
({ rootExpr := rootExpr, ... | null | true |
_private.Lean.Parser.Command.0.Lean.Parser.Term.quot._regBuiltin.Lean.Parser.Term.quot.formatter_9 | Lean.Parser.Command | IO Unit | null | false |
IsAzumaya.recOn | Mathlib.Algebra.Azumaya.Defs | {R : Type u_1} →
{A : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[inst_2 : Algebra R A] →
{motive : IsAzumaya R A → Sort u} →
(t : IsAzumaya R A) →
([toProjective : Module.Projective R A] →
[toFaithfulSMul : FaithfulSMul R A] →... | null | false |
CategoryTheory.Limits.wideCoequalizerIsWideCoequalizer | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | {J : Type w} →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
(f : J → (X ⟶ Y)) →
[inst_1 : CategoryTheory.Limits.HasWideCoequalizer f] →
[inst_2 : Nonempty J] →
CategoryTheory.Limits.IsColimit
(CategoryTheory.Limits.Cotride... | The cotrident built from `wideCoequalizer.π f` is colimiting. | true |
CommMonoidWithZero.zero_mul | Mathlib.Algebra.GroupWithZero.Defs | ∀ {M₀ : Type u_2} [self : CommMonoidWithZero M₀] (a : M₀), 0 * a = 0 | Zero is a left absorbing element for multiplication | true |
length_permsOfList | Mathlib.Data.Fintype.Perm | ∀ {α : Type u_1} [inst : DecidableEq α] (l : List α), (permsOfList l).length = l.length.factorial | null | true |
Frm.hom_ext_iff | Mathlib.Order.Category.Frm | ∀ {X Y : Frm} {f g : X ⟶ Y}, f = g ↔ Frm.Hom.hom f = Frm.Hom.hom g | null | true |
Nat.choose_mul_factorial_mul_factorial | Mathlib.Data.Nat.Choose.Basic | ∀ {n k : ℕ}, k ≤ n → n.choose k * k.factorial * (n - k).factorial = n.factorial | null | true |
Subring.op_top | Mathlib.Algebra.Ring.Subring.MulOpposite | ∀ {R : Type u_2} [inst : NonAssocRing R], ⊤.op = ⊤ | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.0.PeriodPair.mem_lattice._simp_1_2 | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {x y z : M},
(z ∈ Submodule.span R {x, y}) = ∃ a b, a • x + b • y = z | null | false |
ZFSet.Definable | Mathlib.SetTheory.ZFC.Basic | (n : ℕ) → ((Fin n → ZFSet.{u}) → ZFSet.{u}) → Type (u + 1) | A set function is "definable" if it is the image of some n-ary `PSet`
function. This isn't exactly definability, but is useful as a sufficient
condition for functions that have a computable image. | true |
CategoryTheory.ShortComplex.RightHomologyMapData.noConfusion | Mathlib.Algebra.Homology.ShortComplex.RightHomology | {P : Sort u} →
{C : Type u_1} →
{inst : CategoryTheory.Category.{v_1, u_1} C} →
{inst_1 : CategoryTheory.Limits.HasZeroMorphisms C} →
{S₁ S₂ : CategoryTheory.ShortComplex C} →
{φ : S₁ ⟶ S₂} →
{h₁ : S₁.RightHomologyData} →
{h₂ : S₂.RightHomologyData} →
... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.