name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
FirstOrder.Language.StrongHomClass.mk._flat_ctor | Mathlib.ModelTheory.Basic | ∀ {L : outParam FirstOrder.Language} {F : Type u_3} {M : outParam (Type u_4)} {N : outParam (Type u_5)}
[inst : FunLike F M N] [inst_1 : L.Structure M] [inst_2 : L.Structure N],
(∀ (φ : F) {n : ℕ} (f : L.Functions n) (x : Fin n → M),
φ (FirstOrder.Language.Structure.funMap f x) = FirstOrder.Language.Structure... | null | false |
MonoidHom.codRestrict_apply | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {S : Type u_5} [inst_2 : SetLike S N]
[inst_3 : SubmonoidClass S N] (f : M →* N) (s : S) (h : ∀ (x : M), f x ∈ s) (n : M), (f.codRestrict s h) n = ⟨f n, ⋯⟩ | null | true |
_private.Lean.Elab.Do.Legacy.0.Lean.Elab.Term.Do.ToTerm.toTerm.go | Lean.Elab.Do.Legacy | Lean.Elab.Term.Do.Code → Lean.Elab.Term.Do.ToTerm.M Lean.Syntax | null | true |
_private.Lean.Parser.Term.0.Lean.Parser.Term.pipeCompletion._regBuiltin.Lean.Parser.Term.pipeCompletion_1 | Lean.Parser.Term | IO Unit | null | false |
_private.Mathlib.Combinatorics.Matroid.Constructions.0.Matroid.eq_loopyOn_iff._simp_1_2 | Mathlib.Combinatorics.Matroid.Constructions | ∀ {a b c : Prop}, (a ∧ b ↔ a ∧ c) = (a → (b ↔ c)) | null | false |
NonUnitalSubalgebra.casesOn | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | {R : Type u} →
{A : Type v} →
[inst : CommSemiring R] →
[inst_1 : NonUnitalNonAssocSemiring A] →
[inst_2 : Module R A] →
{motive : NonUnitalSubalgebra R A → Sort u_1} →
(t : NonUnitalSubalgebra R A) →
((toNonUnitalSubsemiring : NonUnitalSubsemiring A) →
... | null | false |
ContinuousOn.image_connectedComponentIn_subset | Mathlib.Topology.Connected.Basic | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β} {s : Set α} {a : α},
ContinuousOn f s → a ∈ s → f '' connectedComponentIn s a ⊆ connectedComponentIn (f '' s) (f a) | null | true |
LowerSet.prod_self_le_prod_self._simp_1 | Mathlib.Order.UpperLower.Prod | ∀ {α : Type u_1} [inst : Preorder α] {s₁ s₂ : LowerSet α}, (s₁ ×ˢ s₁ ≤ s₂ ×ˢ s₂) = (s₁ ≤ s₂) | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get?_insert._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
Set.Ioo_subset_Ioo_right | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a₁ a₂ b : α}, a₂ ≤ a₁ → Set.Ioo b a₂ ⊆ Set.Ioo b a₁ | null | true |
Dyadic.le_refl | Init.Data.Dyadic.Basic | ∀ (x : Dyadic), x ≤ x | null | true |
OrderEmbedding.ofAntisymmetrization._proof_2 | Mathlib.Order.Antisymmetrization | ∀ (α : Type u_1) [inst : Preorder α] {a b : Quotient (AntisymmRel.setoid α fun x1 x2 => x1 ≤ x2)},
(Quotient.outRelEmbedding ⋯).toEmbedding a ≤ (Quotient.outRelEmbedding ⋯).toEmbedding b ↔ Quotient.lift₂ LE.le ⋯ a b | null | false |
_private.Lean.MonadEnv.0.Lean.matchConstInduct._sparseCasesOn_1 | Lean.MonadEnv | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.InductiveVal) → motive (Lean.ConstantInfo.inductInfo val)) →
(Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | null | false |
Stream'.map_tail | Mathlib.Data.Stream.Init | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Stream' α), Stream'.map f s.tail = (Stream'.map f s).tail | null | true |
Homeomorph.flow._proof_4 | Mathlib.Dynamics.Flow | ∀ {α : Type u_1} [inst : TopologicalSpace α] (f : α ≃ₜ α) (x : α), (f ^ 0) x = x | null | false |
TopCat.Presheaf.generateEquivalenceOpensLe_inverse' | Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover | {X : TopCat} →
{ι : Type u_2} →
(U : ι → TopologicalSpace.Opens ↑X) →
{Y : TopologicalSpace.Opens ↑X} →
Y = iSup U →
CategoryTheory.Functor (TopCat.Presheaf.SheafCondition.OpensLeCover U)
(CategoryTheory.ObjectProperty.FullSubcategory fun f =>
(CategoryTheory.Siev... | Given a family of opens `U` and an open `Y` equal to the union of opens in `U`, we may
take the presieve on `Y` associated to `U` and the sieve generated by it, and form the
full subcategory (subposet) of opens contained in `Y` (`over Y`) consisting of arrows
in the sieve. This full subcategory is equivalent to `OpensL... | true |
ConditionallyCompleteLinearOrderedField.inducedMap_inducedMap | Mathlib.Algebra.Order.CompleteField | ∀ (α : Type u_1) (β : Type u_2) (γ : Type u_3) [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α]
[inst_3 : Field β] [inst_4 : ConditionallyCompleteLinearOrder β] [IsStrictOrderedRing β] [inst_6 : Field γ]
[inst_7 : ConditionallyCompleteLinearOrder γ] [IsStrictOrderedRing γ] [Archimedean α] (a : α),
... | null | true |
Matrix.coe_ofLinearEquiv_symm | Mathlib.Data.Matrix.Basic | ∀ {m : Type u_2} {n : Type u_3} (R : Type u_4) {α : Type u_8} [inst : Semiring R] [inst_1 : AddCommMonoid α]
[inst_2 : Module R α], ⇑(Matrix.ofLinearEquiv R).symm = ⇑Matrix.of.symm | null | true |
CategoryTheory.Limits.IndObjectPresentation.ofCocone_I | Mathlib.CategoryTheory.Limits.Indization.IndObject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {I : Type v} [inst_1 : CategoryTheory.SmallCategory I]
[inst_2 : CategoryTheory.IsFiltered I] {F : CategoryTheory.Functor I C}
(c : CategoryTheory.Limits.Cocone (F.comp CategoryTheory.yoneda)) (hc : CategoryTheory.Limits.IsColimit c),
(CategoryTheory.Limits... | null | true |
Std.Async.TCP.Socket.Client.noConfusionType | Std.Async.TCP | Sort u → Std.Async.TCP.Socket.Client → Std.Async.TCP.Socket.Client → Sort u | null | false |
_private.Lean.Parser.Term.0.Lean.Parser.Term.privateDecl._regBuiltin.Lean.Parser.Term.privateDecl_1 | Lean.Parser.Term | IO Unit | null | false |
FreeAddMonoid.reverse.eq_1 | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1}, FreeAddMonoid.reverse = List.reverse | null | true |
ChangeOfRings.«_aux_Mathlib_Algebra_Category_ModuleCat_ChangeOfRings___macroRules_ChangeOfRings_term_⊗ₜ[_,_]__1» | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | Lean.Macro | null | false |
selfAdjoint.instOneSubtypeMemAddSubgroup | Mathlib.Algebra.Star.SelfAdjoint | {R : Type u_1} → [inst : Ring R] → [inst_1 : StarRing R] → One ↥(selfAdjoint R) | null | true |
TwoP.largeCategory._aux_5 | Mathlib.CategoryTheory.Category.TwoP | {X Y Z : TwoP} → (X ⟶ Y) → (Y ⟶ Z) → (X ⟶ Z) | null | false |
Eq.rec | Init.Prelude | {α : Sort u_1} →
{a : α} → {motive : (a_1 : α) → a = a_1 → Sort u} → motive a ⋯ → {a_1 : α} → (t : a = a_1) → motive a_1 t | null | false |
MulEquiv.prodUnits.match_1 | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_1} {N : Type u_2} [inst : Monoid M] [inst_1 : Monoid N] (motive : Mˣ × Nˣ → Prop) (x : Mˣ × Nˣ),
(∀ (u₁ : Mˣ) (u₂ : Nˣ), motive (u₁, u₂)) → motive x | null | false |
instDecidablePredMemUpperClosure.eq_1 | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} [inst : Preorder α] {s : Set α} [inst_1 : DecidablePred fun x => ∃ a ∈ s, a ≤ x],
instDecidablePredMemUpperClosure = inst_1 | null | true |
CategoryTheory.kernelCokernelCompSequence.snakeInput_v₁₂_τ₁ | Mathlib.CategoryTheory.Abelian.DiagramLemmas.KernelCokernelComp | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {X Y Z : C} (f : X ⟶ Y)
(g : Y ⟶ Z), (CategoryTheory.kernelCokernelCompSequence.snakeInput f g).v₁₂.τ₁ = f | null | true |
_private.Mathlib.Algebra.Star.NonUnitalSubalgebra.0.NonUnitalStarAlgebra.toNonUnitalSubalgebra_bot._simp_1_2 | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A] {x : A}, (x ∈ ⊥) = (x = 0) | null | false |
CategoryTheory.Limits.cospanIsoMk._auto_3 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan | Lean.Syntax | null | false |
_private.Mathlib.Topology.Homotopy.HSpaces.0.unitInterval.qRight_one_left._simp_1_1 | Mathlib.Topology.Homotopy.HSpaces | ∀ {α : Type u_1} {b c : α} [inst : Add α] [inst_1 : LE α] [AddRightMono α] [AddRightReflectLE α] (a : α),
(b + a ≤ c + a) = (b ≤ c) | null | false |
CochainComplex.Plus.modelCategoryQuillen.fibration_iff | Mathlib.Algebra.Homology.ModelCategory.Injective | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{X Y : CochainComplex.Plus C} (f : X ⟶ Y),
HomotopicalAlgebra.Fibration f ↔ CochainComplex.degreewiseEpiWithInjectiveKernel f.hom | null | true |
_private.Mathlib.RingTheory.AlgebraicIndependent.Defs.0.isTranscendenceBasis_equiv._simp_1_2 | Mathlib.RingTheory.AlgebraicIndependent.Defs | ∀ {ι : Type u_1} {ι' : Type u_2} {R : Type u_3} {A : Type u_4} [inst : CommRing R] [inst_1 : CommRing A]
[inst_2 : Algebra R A] (e : ι ≃ ι') {f : ι' → A}, AlgebraicIndependent R (f ∘ ⇑e) = AlgebraicIndependent R f | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toInt_ushiftRight_of_lt._simp_1_1 | Init.Data.BitVec.Lemmas | ∀ {α : Sort u_1} {p : Prop} [inst : Decidable p] {x y : α}, ((if p then x else y) = x) = (¬p → y = x) | null | false |
_private.Lean.Meta.LetToHave.0.Lean.Meta.LetToHave.visitLambdaLet.go._unsafe_rec | Lean.Meta.LetToHave | Lean.LocalContext → Array Lean.Expr → Lean.Expr → List Lean.FVarId → Lean.Meta.LetToHave.M✝ Lean.Meta.LetToHave.Result✝ | null | false |
CompleteLattice.toConditionallyCompleteLattice | Mathlib.Order.ConditionallyCompleteLattice.Basic | {α : Type u_1} → [CompleteLattice α] → ConditionallyCompleteLattice α | A complete lattice is a conditionally complete lattice, as there are no restrictions
on the properties of sInf and sSup in a complete lattice. | true |
Lean.MVarId.mk.sizeOf_spec | Lean.Expr | ∀ (name : Lean.Name), sizeOf { name := name } = 1 + sizeOf name | null | true |
Std.Net.SocketAddress.v6.noConfusion | Std.Net.Addr | {P : Sort u} →
{addr addr' : Std.Net.SocketAddressV6} →
Std.Net.SocketAddress.v6 addr = Std.Net.SocketAddress.v6 addr' → (addr = addr' → P) → P | null | false |
cfcₙ_const_mul_id | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : CommSemiring R] [inst_1 : Nontrivial R] [inst_2 : StarRing R]
[inst_3 : MetricSpace R] [inst_4 : IsTopologicalSemiring R] [inst_5 : ContinuousStar R] [inst_6 : NonUnitalRing A]
[inst_7 : StarRing A] [inst_8 : TopologicalSpace A] [inst_9 : Module R A] [inst_10 :... | null | true |
GroupCone.casesOn | Mathlib.Algebra.Order.Group.Cone | {G : Type u_1} →
[inst : CommGroup G] →
{motive : GroupCone G → Sort u} →
(t : GroupCone G) →
((toSubmonoid : Submonoid G) →
(eq_one_of_mem_of_inv_mem' : ∀ {a : G}, a ∈ toSubmonoid.carrier → a⁻¹ ∈ toSubmonoid.carrier → a = 1) →
motive { toSubmonoid := toSubmonoid, eq_one_of... | null | false |
Real.image_log_Ioo | Mathlib.Analysis.SpecialFunctions.Log.Basic | ∀ {a b : ℝ}, 0 < a → a ≤ b → Real.log '' Set.Ioo a b = Set.Ioo (Real.log a) (Real.log b) | null | true |
CategoryTheory.Limits.isLimitOfHasPullbackOfPreservesLimit | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Pullbacks | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(G : CategoryTheory.Functor C D) →
{X Y Z : C} →
(f : X ⟶ Z) →
(g : Y ⟶ Z) →
[CategoryTheory.Limits.PreservesLimit (Catego... | If `G` preserves pullbacks and `C` has them, then the pullback cone constructed of the mapped
morphisms of the pullback cone is a limit. | true |
Polynomial.toMatrix_sylvesterMap' | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {m n : ℕ} {R : Type u_1} [inst : CommRing R] (f g : Polynomial R) (hf : f.natDegree ≤ m) (hg : g.natDegree ≤ n),
(LinearMap.toMatrix (((Polynomial.degreeLT.basis R m).prod (Polynomial.degreeLT.basis R n)).reindex finSumFinEquiv)
(Polynomial.degreeLT.basis R (m + n)))
(f.sylvesterMap g hf hg) =
f.s... | null | true |
_private.Lean.PrettyPrinter.Delaborator.Builtins.0.Lean.PrettyPrinter.Delaborator.delabDo._regBuiltin.Lean.PrettyPrinter.Delaborator.delabDo_1 | Lean.PrettyPrinter.Delaborator.Builtins | IO Unit | null | false |
Option.instSMul_mathlib.eq_1 | Mathlib.Algebra.Group.Action.Option | ∀ {M : Type u_1} {α : Type u_3} [inst : SMul M α],
Option.instSMul_mathlib = { smul := fun a => Option.map fun x => a • x } | null | true |
_private.Mathlib.NumberTheory.Padics.Hensel.0.newton_seq_succ_dist_weak | Mathlib.NumberTheory.Padics.Hensel | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] {R : Type u_1} [inst_1 : CommSemiring R] [inst_2 : Algebra R ℤ_[p]]
{F : Polynomial R} {a : ℤ_[p]}
(hnorm : ‖(Polynomial.aeval a) F‖ < ‖(Polynomial.aeval a) (Polynomial.derivative F)‖ ^ 2),
(Polynomial.aeval a) F ≠ 0 →
∀ (n : ℕ),
‖newton_seq_gen✝ hnorm (n + 2) - new... | null | true |
CuspForm.discriminantEquiv._proof_5 | Mathlib.NumberTheory.ModularForms.LevelOne.DimensionFormula | ∀ {k : ℤ} (c : ℂ) (a : CuspForm (Matrix.SpecialLinearGroup.mapGL ℝ).range k),
{ toFun := fun z => (c • a) z / ModularForm.discriminant z, slash_action_eq' := ⋯, holo' := ⋯, bdd_at_cusps' := ⋯ } =
(RingHom.id ℂ) c •
{ toFun := fun z => a z / ModularForm.discriminant z, slash_action_eq' := ⋯, holo' := ⋯, bdd_... | null | false |
LieSubalgebra.exists_lieIdeal_coe_eq_iff | Mathlib.Algebra.Lie.Ideal | ∀ (R : Type u) {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (K : LieSubalgebra R L),
(∃ I, ↑R L I = K) ↔ ∀ (x y : L), y ∈ K → ⁅x, y⁆ ∈ K | null | true |
NonUnitalAlgebra.mem_sInf | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A] {S : Set (NonUnitalSubalgebra R A)} {x : A},
x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p | null | true |
PowerSeries.isRestricted_monomial | Mathlib.RingTheory.PowerSeries.Restricted | ∀ {R : Type u_1} [inst : NormedRing R] (c : ℝ) (n : ℕ) (a : R), PowerSeries.IsRestricted c ((PowerSeries.monomial n) a) | null | true |
CategoryTheory.CatCommSq.mk._flat_ctor | Mathlib.CategoryTheory.CatCommSq | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{C₃ : Type u_3} →
{C₄ : Type u_4} →
[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₃] →
[inst_3 : CategoryTheory.Category.{v_4, u... | null | false |
CategoryTheory.Arrow.w_mk._to_dual_1 | Mathlib.CategoryTheory.Comma.Arrow | ∀ {T : Type u} [inst : CategoryTheory.Category.{v, u} T] {X Y X' Y' : T} {f : Y ⟶ X} {g : Y' ⟶ X'}
(sq : CategoryTheory.Arrow.mk g ⟶ CategoryTheory.Arrow.mk f),
CategoryTheory.CategoryStruct.comp g (CategoryTheory.Arrow.Hom.right sq) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Arrow.Hom.left sq) f | null | false |
Matrix.toBlocks_fromBlocks₂₁ | Mathlib.Data.Matrix.Block | ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type u_11} (A : Matrix n l α) (B : Matrix n m α)
(C : Matrix o l α) (D : Matrix o m α), (Matrix.fromBlocks A B C D).toBlocks₂₁ = C | null | true |
_private.Mathlib.Tactic.Linter.Whitespace.0.Mathlib.Linter.parallelScanAux | Mathlib.Tactic.Linter.Whitespace | Array Mathlib.Linter.FormatError✝ → String.Slice → String.Slice → Array Mathlib.Linter.FormatError✝ | Scan the two input strings `L` and `M`, assuming `M` is the pretty-printed version of `L`.
This almost means that `L` and `M` only differ in whitespace.
While scanning the two strings, accumulate any discrepancies --- with some heuristics to avoid
flagging some line-breaking changes.
(The pretty-printer does not alway... | true |
Std.Time.TimeZone.TransitionSpec.casesOn | Std.Time.Zoned.RecurringRule | {motive : Std.Time.TimeZone.TransitionSpec → Sort u} →
(t : Std.Time.TimeZone.TransitionSpec) →
((month : Std.Time.Month.Ordinal) →
(week : Std.Time.Week.Aligned.Ordinal) →
(day : Std.Time.Weekday.Ordinal) → motive (Std.Time.TimeZone.TransitionSpec.mwd month week day)) →
((day : Std.Time.I... | null | false |
Submodule.span_span_coe_preimage | Mathlib.LinearAlgebra.Span.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {s : Set M},
Submodule.span R (Subtype.val ⁻¹' s) = ⊤ | null | true |
Int.dvd_emod_add_of_dvd_add | Init.Data.Int.Cooper | ∀ {a c d x : ℤ}, a ∣ x + c → a ∣ d → a ∣ x % d + c | Given a solution `x` to a divisibility constraint `a ∣ x + c`,
then `x % d` is another solution as long as `a | d`.
See `dvd_mul_emod_add_of_dvd_mul_add` for a more general version allowing a coefficient with `x`.
| true |
SimpleGraph.Subgraph.coeInduceIso._proof_8 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} {G' : G.Subgraph} (s : Set V) (h : s ⊆ G'.verts),
Function.RightInverse
(fun x =>
match x with
| ⟨v, hv⟩ => ⟨↑v, hv⟩)
fun x =>
match x with
| ⟨v, hv⟩ => ⟨⟨v, ⋯⟩, ⋯⟩ | null | false |
CategoryTheory.StrictlyUnitaryLaxFunctorCore.map_id._autoParam | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | Lean.Syntax | null | false |
ClosedEmbeddingContinuousFunctionalCalculus.recOn | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | {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 |
Std.Time.PlainTime.ofSeconds | Std.Time.Time.PlainTime | Std.Time.Second.Offset → Std.Time.PlainTime | Creates a `PlainTime` value from a total number of seconds.
| true |
OrderRingIso.noConfusion | Mathlib.Algebra.Order.Hom.Ring | {P : Sort u} →
{α : Type u_6} →
{β : Type u_7} →
{inst : Mul α} →
{inst_1 : Add α} →
{inst_2 : Mul β} →
{inst_3 : Add β} →
{inst_4 : LE α} →
{inst_5 : LE β} →
{t : α ≃+*o β} →
{α' : Type u_6} →
... | null | false |
ENNReal.measurableSpace | Mathlib.MeasureTheory.Constructions.BorelSpace.Basic | MeasurableSpace ENNReal | null | true |
_private.Mathlib.Algebra.QuadraticDiscriminant.0.discrim_eq_zero_iff._simp_1_1 | Mathlib.Algebra.QuadraticDiscriminant | ∀ {α : Sort u_1} {a' : α}, (∃! a, a = a') = True | null | false |
CategoryTheory.Localization.lift₃NatTrans | Mathlib.CategoryTheory.Localization.Trifunctor | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{C₃ : Type u_3} →
{D₁ : Type u_6} →
{D₂ : Type u_7} →
{D₃ : Type u_8} →
{E : Type u_13} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] →
[ins... | The natural transformation `F₁' ⟶ F₂'` of trifunctors induced by a
natural transformation `τ : F₁ ⟶ F₂` when `Lifting₃ L₁ L₂ L₃ W₁ W₂ W₃ F₁ F₁'`
and `Lifting₃ L₁ L₂ L₃ W₁ W₂ W₃ F₂ F₂'` hold. | true |
Shrink.instNormedAddCommGroup._proof_2 | Mathlib.Analysis.Normed.Module.Shrink | ∀ {α : Type u_2} [inst : Small.{u_1, u_2} α] [inst_1 : NormedAddCommGroup α],
autoParam (∀ (x y : Shrink.{u_1, u_2} α), dist x y = ‖-x + y‖) NormedAddCommGroup.dist_eq._autoParam | null | false |
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.checkDefaultSplitStatus | Lean.Meta.Tactic.Grind.Split | Lean.Expr → Lean.Meta.Grind.GoalM Lean.Meta.Grind.SplitStatus | null | true |
QuasiErgodic.mk._flat_ctor | Mathlib.Dynamics.Ergodic.Ergodic | ∀ {α : Type u_1} {m : MeasurableSpace α} {f : α → α} {μ : autoParam (MeasureTheory.Measure α) QuasiErgodic._auto_1},
Measurable f →
(MeasureTheory.Measure.map f μ).AbsolutelyContinuous μ →
(∀ ⦃s : Set α⦄,
MeasureTheory.NullMeasurableSet s μ → f ⁻¹' s =ᵐ[μ] s → Filter.EventuallyEmptyOrUniv s (Measu... | null | false |
CategoryTheory.ShortComplex.exact_of_g_is_cokernel | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
(S : CategoryTheory.ShortComplex C)
(hS : CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.CokernelCofork.ofπ S.g ⋯)) [S.HasHomology], S.Exact | null | true |
CategoryTheory.IsCofiltered.cofilteredClosure.below | Mathlib.CategoryTheory.Filtered.Small | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.IsCofilteredOrEmpty C] →
{α : Type w} →
{f : α → C} →
{motive : (a : C) → CategoryTheory.IsCofiltered.cofilteredClosure f a → Prop} →
{a : C} → CategoryTheory.IsCofiltered.cofilteredClosure f a ... | null | true |
Decidable.em | Init.Core | ∀ (p : Prop) [Decidable p], p ∨ ¬p | null | true |
CategoryTheory.equivEssImageOfReflective._proof_2 | Mathlib.CategoryTheory.Adjunction.Reflective | ∀ {C : Type u_4} {D : Type u_3} [inst : CategoryTheory.Category.{u_2, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_3} D] {i : CategoryTheory.Functor D C}
[inst_2 : CategoryTheory.Reflective i] {X Y : i.EssImageSubcategory} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
((((i.essImage.ι.comp (CategoryT... | null | false |
Nat.dfold_add._proof_10 | Init.Data.Nat.Fold | ∀ {n m : ℕ}, ∀ i < n + m, i + 1 ≤ n + m | null | false |
Monotone.leftOrdContinuous | Mathlib.Topology.Order.Monotone | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [OrderTopology α]
[inst_3 : LinearOrder β] {f : α → β} [inst_4 : TopologicalSpace β] [OrderTopology β],
Monotone f → (∀ (x : α), ContinuousWithinAt f (Set.Iic x) x) → LeftOrdContinuous f | A monotone left-continuous function is left-continuous in the order-theoretic sense. | true |
CategoryTheory.EnrichedCategory.mk | Mathlib.CategoryTheory.Enriched.Basic | {V : Type v} →
[inst : CategoryTheory.Category.{w, v} V] →
[inst_1 : CategoryTheory.MonoidalCategory V] →
{C : Type u₁} →
(Hom : C → C → V) →
(id : (X : C) → CategoryTheory.MonoidalCategoryStruct.tensorUnit V ⟶ Hom X X) →
(comp : (X Y Z : C) → CategoryTheory.MonoidalCategoryStr... | null | true |
CategoryTheory.OppositeShift.adjunction_counit | Mathlib.CategoryTheory.Shift.Opposite | ∀ {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] (A : Type u_3) [inst_2 : AddMonoid A]
[inst_3 : CategoryTheory.HasShift C A] [inst_4 : CategoryTheory.HasShift D A] {F : CategoryTheory.Functor C D}
{G : CategoryTheory.Functor D C} (adj :... | null | true |
Lean.Elab.instInhabitedDecreasingBy | Lean.Elab.PreDefinition.TerminationHint | Inhabited Lean.Elab.DecreasingBy | null | true |
ContinuousLinearMap.HasLeftInverse.of_comp | Mathlib.Analysis.Normed.Module.ContinuousInverse | ∀ {R : Type u_1} [inst : Semiring R] {E : Type u_2} {F : Type u_4} {G : Type u_6} [inst_1 : TopologicalSpace E]
[inst_2 : AddCommMonoid E] [inst_3 : Module R E] [inst_4 : TopologicalSpace F] [inst_5 : AddCommMonoid F]
[inst_6 : Module R F] {f : E →L[R] F} [inst_7 : TopologicalSpace G] [inst_8 : AddCommMonoid G] [in... | null | true |
vadd_closedBall_zero | Mathlib.Analysis.Normed.Group.Pointwise | ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] (δ : ℝ) (x : E), x +ᵥ Metric.closedBall 0 δ = Metric.closedBall x δ | null | true |
Std.Rci.getElem_toList_eq | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rci α} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.PRange.LawfulUpwardEnumerable α] [inst_4 : Std.PRange.LawfulUpwardEnumerableLT α]
[inst_5 : Std.Rxi.IsAlwaysFinite α] {i : ℕ} {h : i < r.toList.length},
r.toList[i] = (Std.PRange.succMany? ... | null | true |
CategoryTheory.Functor.PreservesRightKanExtension.mk | Mathlib.CategoryTheory.Functor.KanExtension.Preserves | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} {D : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} A]
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] [inst_2 : CategoryTheory.Category.{v_3, u_3} C]
[inst_3 : CategoryTheory.Category.{v_4, u_4} D] {G : CategoryTheory.Functor B D} {F : CategoryTheory.Functor A B... | null | true |
OpenNormalAddSubgroup.instSemilatticeInfOpenNormalAddSubgroup._proof_2 | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] {x y : OpenNormalAddSubgroup G}, ↑y ⊆ ↑x ↔ ↑y ⊆ ↑x | null | false |
Set.neg_mem_Ioc_iff | Mathlib.Algebra.Order.Interval.Set.Group | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α] {a c d : α},
-a ∈ Set.Ioc c d ↔ a ∈ Set.Ico (-d) (-c) | null | true |
CategoryTheory.ShiftMkCore._proof_1 | Mathlib.CategoryTheory.Shift.Basic | ∀ (C : Type u_1) (A : Type u_3) [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : AddMonoid A]
(F : A → CategoryTheory.Functor C C) (m₁ m₂ m₃ : A) (X : C), (F (m₁ + m₂ + m₃)).obj X = (F (m₁ + (m₂ + m₃))).obj X | null | false |
Finset.card_eq_of_equiv_fin | Mathlib.Data.Fintype.EquivFin | ∀ {α : Type u_1} {s : Finset α} {n : ℕ} (i : ↥s ≃ Fin n), s.card = n | null | true |
_private.Lean.Compiler.LCNF.PhaseExt.0.Lean.Compiler.LCNF.isDeclTransparent.match_1 | Lean.Compiler.LCNF.PhaseExt | (motive : List Lean.Name × Lean.NameSet → Sort u_1) →
(x : List Lean.Name × Lean.NameSet) → ((fst : List Lean.Name) → (map : Lean.NameSet) → motive (fst, map)) → motive x | null | false |
WithAbs.instSemiring._proof_14 | Mathlib.Analysis.Normed.Ring.WithAbs | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring S] [inst_1 : PartialOrder S] [inst_2 : Semiring R]
(v : AbsoluteValue R S) (a : WithAbs v), 0 * a = 0 | null | false |
CategoryTheory.Square.ctorIdx | Mathlib.CategoryTheory.Square | {C : Type u} → {inst : CategoryTheory.Category.{v, u} C} → CategoryTheory.Square C → ℕ | null | false |
BoundedOrderHom.cancel_right._simp_1 | Mathlib.Order.Hom.Bounded | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
[inst_3 : BoundedOrder α] [inst_4 : BoundedOrder β] [inst_5 : BoundedOrder γ] {g₁ g₂ : BoundedOrderHom β γ}
{f : BoundedOrderHom α β}, Function.Surjective ⇑f → (g₁.comp f = g₂.comp f) = (g₁ = g₂) | null | false |
Besicovitch.SatelliteConfig.mk | Mathlib.MeasureTheory.Covering.Besicovitch | {α : Type u_1} →
[inst : MetricSpace α] →
{N : ℕ} →
{τ : ℝ} →
(c : Fin N.succ → α) →
(r : Fin N.succ → ℝ) →
(∀ (i : Fin N.succ), 0 < r i) →
(Pairwise fun i j => r i ≤ dist (c i) (c j) ∧ r j ≤ τ * r i ∨ r j ≤ dist (c j) (c i) ∧ r i ≤ τ * r j) →
(∀ i... | null | true |
TendstoUniformlyOn.prodMap | Mathlib.Topology.UniformSpace.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_4} [inst : UniformSpace β] {F : ι → α → β} {f : α → β} {s : Set α}
{p : Filter ι} {ι' : Type u_5} {α' : Type u_6} {β' : Type u_7} [inst_1 : UniformSpace β'] {F' : ι' → α' → β'}
{f' : α' → β'} {p' : Filter ι'} {s' : Set α'},
TendstoUniformlyOn F f p s →
TendstoUnifor... | null | true |
_private.Mathlib.Analysis.InnerProductSpace.TensorProduct.0.ContinuousLinearMap.lTensor_apply._simp_1_2 | Mathlib.Analysis.InnerProductSpace.TensorProduct | ∀ {R : Type u_1} [inst : CommSemiring R] {N : Type u_5} {P : Type u_6} {Q : Type u_7} [inst_1 : AddCommMonoid N]
[inst_2 : AddCommMonoid P] [inst_3 : AddCommMonoid Q] [inst_4 : Module R N] [inst_5 : Module R P]
[inst_6 : Module R Q] (g : N →ₗ[R] P),
LinearMap.lTensor Q g = ↑(TensorProduct.comm R P Q) ∘ₗ LinearMap... | null | false |
padicNormE._proof_5 | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] (q : ℚ_[p]), Quotient.lift PadicSeq.norm ⋯ q = 0 ↔ q = 0 | null | false |
FunctionField.Algebra.IsAlgebraic.adjoin_algebraMap_X | Mathlib.NumberTheory.FunctionField | ∀ {F : Type u_3} {K : Type u_4} [inst : Field F] [inst_1 : Field K] [inst_2 : Algebra (RatFunc F) K] [FunctionField F K]
[inst_4 : Algebra F K] [IsScalarTower F (RatFunc F) K],
Algebra.IsAlgebraic (↥F⟮(algebraMap (RatFunc F) K) RatFunc.X⟯) K | null | true |
Quaternion.linearIsometryEquivTuple._proof_5 | Mathlib.Analysis.Quaternion | ∀ (x y : QuaternionAlgebra ℝ (-1) 0 (-1)),
(↑((QuaternionAlgebra.linearEquivTuple (-1) 0 (-1)).trans (WithLp.linearEquiv 2 ℝ (Fin 4 → ℝ)).symm)).toFun (x + y) =
(↑((QuaternionAlgebra.linearEquivTuple (-1) 0 (-1)).trans (WithLp.linearEquiv 2 ℝ (Fin 4 → ℝ)).symm)).toFun x +
(↑((QuaternionAlgebra.linearEquivTu... | null | false |
_private.Std.Data.DHashMap.RawLemmas.0.Std.DHashMap.Raw.Const.size_filter_eq_size_iff._simp_1_1 | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β} {a : α},
(a ∈ m) = (m.contains a = true) | null | false |
AdicCompletion.sumInv | Mathlib.RingTheory.AdicCompletion.Functoriality | {R : Type u_1} →
[inst : CommRing R] →
(I : Ideal R) →
{ι : Type u_6} →
(M : ι → Type u_7) →
[inst_1 : (i : ι) → AddCommGroup (M i)] →
[inst_2 : (i : ι) → Module R (M i)] →
[Fintype ι] →
AdicCompletion I (DirectSum ι fun j => M j) →ₗ[AdicCompletion... | If `ι` is finite, we use the equivalence of sum and product to obtain an inverse for
`AdicCompletion.sum` from `AdicCompletion.pi`. | true |
DifferentiableAt.div | Mathlib.Analysis.Calculus.Deriv.Inv | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {𝕜' : Type u_1} [inst_1 : NontriviallyNormedField 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] {c d : 𝕜 → 𝕜'},
DifferentiableAt 𝕜 c x → DifferentiableAt 𝕜 d x → d x ≠ 0 → DifferentiableAt 𝕜 (c / d) x | null | true |
Equiv.Set.union_apply_left | Mathlib.Logic.Equiv.Set | ∀ {α : Type u_3} {s t : Set α} [inst : DecidablePred fun x => x ∈ s] (H : Disjoint s t) {a : ↑(s ∪ t)} (ha : ↑a ∈ s),
(Equiv.Set.union H) a = Sum.inl ⟨↑a, ha⟩ | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.