name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.Limits.isTerminalEquivUnique._proof_5 | Mathlib.CategoryTheory.Limits.Shapes.IsTerminal | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C]
(F : CategoryTheory.Functor (CategoryTheory.Discrete PEmpty.{1}) C) (Y : C) (u : (X : C) → Unique (X ⟶ Y))
(s : CategoryTheory.Limits.Cone F) (j : CategoryTheory.Discrete PEmpty.{1}),
CategoryTheory.CategoryStruct.comp default
({ pt := Y,
... | null | false |
PFunctor.Approx.sCorec._unsafe_rec | Mathlib.Data.PFunctor.Univariate.M | {F : PFunctor.{uA, uB}} → {X : Type w} → (X → ↑F X) → X → (n : ℕ) → PFunctor.Approx.CofixA F n | null | false |
_private.Std.Data.DTreeMap.Internal.Zipper.0.Std.DTreeMap.Internal.RxoIterator.step_cons_of_isLT | Std.Data.DTreeMap.Internal.Zipper | ∀ {α : Type u} {β : α → Type v} {k : α} {v : β k} {t : Std.DTreeMap.Internal.Impl α β}
{it : Std.DTreeMap.Internal.Zipper α β} [inst : Ord α] {upper : α} {h : (compare k upper).isLT = true},
{ iter := Std.DTreeMap.Internal.Zipper.cons k v t it, upper := upper }.step =
Std.IterStep.yield { internalState := { ite... | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Basic.0.SimpleGraph.EdgeDisjointTriangles.card_edgeFinset_le._simp_1_5 | Mathlib.Combinatorics.SimpleGraph.Triangle.Basic | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
Finset.finsuppAntidiag_insert.match_3 | Mathlib.Algebra.Order.Antidiag.Finsupp | ∀ {ι : Type u_1} {μ : Type u_2} [inst : DecidableEq ι] [inst_1 : AddCommMonoid μ] [inst_2 : Finset.HasAntidiagonal μ]
[inst_3 : DecidableEq μ] {a : ι} {s : Finset ι} (p : μ × μ) (x : ↥(s.finsuppAntidiag p.2))
(motive : (x_1 : ↥(s.finsuppAntidiag p.2)) → (fun f => (↑f).update a p.1) x_1 = (fun f => (↑f).update a p.1... | null | false |
neg_lt_sub_iff_lt_add | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α] [AddLeftStrictMono α] [AddRightStrictMono α] {a b c : α},
-a < b - c ↔ c < a + b | null | true |
Finsupp.basisSingleOne | Mathlib.LinearAlgebra.Finsupp.VectorSpace | {R : Type u_1} → {ι : Type u_3} → [inst : Semiring R] → Module.Basis ι R (ι →₀ R) | The basis on `ι →₀ R` with basis vectors `fun i ↦ single i 1`. | true |
CategoryTheory.Functor.instCommShiftCochainComplexIntDerivedCategoryHomIsoQQuasiIsoUpMapDerivedCategoryId | Mathlib.Algebra.Homology.DerivedCategory.ExactFunctor | ∀ {C₁ : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Abelian C₁]
[inst_2 : HasDerivedCategory C₁],
CategoryTheory.NatTrans.CommShift
(CategoryTheory.Localization.Lifting.iso DerivedCategory.Q (HomologicalComplex.quasiIso C₁ (ComplexShape.up ℤ))
DerivedCategory.Q (Cat... | null | true |
Aesop.Frontend.Priority.int.elim | Aesop.Frontend.RuleExpr | {motive : Aesop.Frontend.Priority → Sort u} →
(t : Aesop.Frontend.Priority) → t.ctorIdx = 0 → ((i : ℤ) → motive (Aesop.Frontend.Priority.int i)) → motive t | null | false |
Lean.Elab.mkMessageCore | Lean.Elab.Exception | String → Lean.FileMap → Lean.MessageData → Lean.MessageSeverity → String.Pos.Raw → String.Pos.Raw → Lean.Message | null | true |
Int.decidableLELT._proof_3 | Mathlib.Data.Int.Range | ∀ (P : ℤ → Prop) (m n : ℤ), (∀ r ∈ m.range n, P r) ↔ ∀ (r : ℤ), m ≤ r → r < n → P r | null | false |
TopCommRingCat.instConcreteCategorySubtypeRingHomαContinuousCoe._proof_3 | Mathlib.Topology.Category.TopCommRingCat | ∀ {X : TopCommRingCat} (x : X.α), (CategoryTheory.CategoryStruct.id X) x = x | null | false |
Lean.Elab.Do.withDeadCode | Lean.Elab.Do.Basic | {α : Type} → Lean.Elab.Do.CodeLiveness → Lean.Elab.Do.DoElabM α → Lean.Elab.Do.DoElabM α | null | true |
CategoryTheory.ShortComplex.instMonoICycles | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [inst_2 : S.HasLeftHomology], CategoryTheory.Mono S.iCycles | null | true |
instMulOneClassWithConvMatrix._proof_1 | Mathlib.LinearAlgebra.Matrix.WithConv | ∀ {m : Type u_3} {n : Type u_2} {α : Type u_1} [inst : MulOneClass α] (a : WithConv (Matrix m n α)), 1 * a = a | null | false |
_private.Mathlib.Combinatorics.Matroid.Loop.0.Matroid.loopyOn_isLoopless_iff._simp_1_1 | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} {M : Matroid α}, M.Loopless = ∀ e ∈ M.E, ¬M.IsLoop e | null | false |
CategoryTheory.SmallObject.ιFunctorObj_eq | Mathlib.CategoryTheory.SmallObject.IsCardinalForSmallObjectArgument | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (I : CategoryTheory.MorphismProperty C) (κ : Cardinal.{w})
[inst_1 : Fact κ.IsRegular] [inst_2 : OrderBot κ.ord.ToType] [inst_3 : I.IsCardinalForSmallObjectArgument κ] {X Y : C}
(f : X ⟶ Y) (j : κ.ord.ToType),
CategoryTheory.SmallObject.ιFunctorObj I.homFam... | null | true |
CategoryTheory.Mon.limit._proof_3 | Mathlib.CategoryTheory.Monoidal.Internal.Limits | ∀ {J : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} J] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] [inst_2 : CategoryTheory.MonoidalCategory C]
(F : CategoryTheory.Functor J (CategoryTheory.Mon C))
(c : CategoryTheory.Limits.Cone (F.comp (CategoryTheory.Mon.forget C))) (i j : J) (f : i ... | null | false |
instLocallyFiniteOrderBotSubtypeLtOfDecidableLTOfLocallyFiniteOrder._proof_1 | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} [inst : Preorder α] {y : α} [inst_1 : DecidableLT α] [inst_2 : LocallyFiniteOrder α]
(a b : { x // y < x }), b ∈ Finset.subtype (fun x => y < x) (Finset.Ioc y ↑a) ↔ b ≤ a | null | false |
RingPreordering.supportAddSubgroup._proof_2 | Mathlib.Algebra.Order.Ring.Ordering.Defs | ∀ {R : Type u_1} [inst : CommRing R] (P : RingPreordering R) {a b : R}, a ∈ ↑P ∩ -↑P → b ∈ ↑P ∩ -↑P → a + b ∈ ↑P ∩ -↑P | null | false |
Function.Injective.extend_update | Mathlib.Logic.Function.Basic | ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} [inst : DecidableEq α] [inst_1 : DecidableEq β],
Function.Injective f →
∀ (g : α → γ) (e : β → γ) (i : α) (a : γ),
Function.extend f (Function.update g i a) e = Function.update (Function.extend f g e) (f i) a | null | true |
Subgroup.map_subtype_le_map_subtype | Mathlib.Algebra.Group.Subgroup.Ker | ∀ {G : Type u_1} [inst : Group G] {G' : Subgroup G} {H K : Subgroup ↥G'},
Subgroup.map G'.subtype H ≤ Subgroup.map G'.subtype K ↔ H ≤ K | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Stirling.0.Stirling.log_stirlingSeq_bounded_aux._proof_1_2 | Mathlib.Analysis.SpecialFunctions.Stirling | ∀ (n : ℕ), 0 ≤ ↑n + 1 | null | false |
LucasLehmer.X.add_snd | Mathlib.NumberTheory.LucasLehmer | ∀ {q : ℕ} (x y : LucasLehmer.X q), (x + y).2 = x.2 + y.2 | null | true |
_private.Mathlib.SetTheory.Ordinal.Veblen.0.Ordinal.cmp_veblenWith.match_1.eq_2 | Mathlib.SetTheory.Ordinal.Veblen | ∀ (motive : Ordering → Sort u_1) (h_1 : Unit → motive Ordering.eq) (h_2 : Unit → motive Ordering.lt)
(h_3 : Unit → motive Ordering.gt),
(match Ordering.lt with
| Ordering.eq => h_1 ()
| Ordering.lt => h_2 ()
| Ordering.gt => h_3 ()) =
h_2 () | null | true |
Lean.Expr.updateForall! | Lean.Expr | Lean.Expr → Lean.BinderInfo → Lean.Expr → Lean.Expr → Lean.Expr | null | true |
_private.Mathlib.Analysis.Asymptotics.Ring.0.Asymptotics.IsBigO.of_const_mul_right.match_1_1 | Mathlib.Analysis.Asymptotics.Ring | ∀ {α : Type u_1} {E : Type u_2} {R : Type u_3} [inst : Norm E] [inst_1 : SeminormedRing R] {f : α → E} {l : Filter α}
{g : α → R} {c : R} (motive : (∃ c_1 ≥ 0, Asymptotics.IsBigOWith c_1 l f fun x => c * g x) → Prop)
(x : ∃ c_1 ≥ 0, Asymptotics.IsBigOWith c_1 l f fun x => c * g x),
(∀ (_c : ℝ) (cnonneg : _c ≥ 0) ... | null | false |
HahnSeries.SummableFamily.embDomain | Mathlib.RingTheory.HahnSeries.Summable | {Γ : Type u_1} →
{R : Type u_3} →
{α : Type u_5} →
{β : Type u_6} →
[inst : PartialOrder Γ] →
[inst_1 : AddCommMonoid R] → HahnSeries.SummableFamily Γ R α → (α ↪ β) → HahnSeries.SummableFamily Γ R β | A summable family can be reindexed by an embedding without changing its sum. | true |
_private.Mathlib.Data.DFinsupp.Defs.0.DFinsupp.filter_single._proof_1_2 | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u_2} {β : ι → Type u_1} [inst : (i : ι) → Zero (β i)] [inst_1 : DecidableEq ι] (p : ι → Prop)
[inst_2 : DecidablePred p] (i : ι) (x : β i) (j : ι),
((if p i then fun₀ | i => x else 0) j = if p i then (fun₀ | i => x) j else 0) →
(DFinsupp.filter p fun₀ | i => x) j = (if p i then fun₀ | i => x else 0)... | null | false |
StarSubalgebra.ofClass._proof_4 | Mathlib.Algebra.Star.Subalgebra | ∀ {S : Type u_2} {A : Type u_1} [inst : Semiring A] [inst_1 : SetLike S A] [SubsemiringClass S A] (s : S), 0 ∈ s | null | false |
MeasureTheory.tendstoInDistribution_of_isEmpty | Mathlib.MeasureTheory.Function.ConvergenceInDistribution | ∀ {ι : Type u_1} {E : Type u_2} {Ω' : Type u_3} {Ω : ι → Type u_5} {m : (i : ι) → MeasurableSpace (Ω i)}
{μ : (i : ι) → MeasureTheory.Measure (Ω i)} [inst : ∀ (i : ι), MeasureTheory.IsProbabilityMeasure (μ i)]
{m' : MeasurableSpace Ω'} {μ' : MeasureTheory.Measure Ω'} [inst_1 : MeasureTheory.IsProbabilityMeasure μ']... | null | true |
AddCommMonCat.instConcreteCategoryAddMonoidHomCarrier._proof_2 | Mathlib.Algebra.Category.MonCat.Basic | ∀ {X Y : AddCommMonCat} (f : X ⟶ Y), { hom' := f.hom' } = f | null | false |
CategoryTheory.Limits.PreservesWellOrderContinuousOfShape.preservesColimitsOfShape | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Preorder | ∀ {C : Type u} {D : Type u'} {inst : CategoryTheory.Category.{v, u} C} {inst_1 : CategoryTheory.Category.{v', u'} D}
{J : Type w} {inst_2 : LinearOrder J} {G : CategoryTheory.Functor C D}
[self : CategoryTheory.Limits.PreservesWellOrderContinuousOfShape J G] (j : J),
Order.IsSuccLimit j → CategoryTheory.Limits.Pr... | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite.0.SimpleGraph.IsPathGraph3Compl.pathGraph3ComplEmbedding.match_1.splitter | Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | (motive : Fin 3 → Sort u_1) → (x : Fin 3) → (Unit → motive 0) → (Unit → motive 1) → (Unit → motive 2) → motive x | null | true |
Lean.EnvironmentHeader.imports._default | Lean.Environment | Array Lean.Import | null | false |
Lean.IR.instToFormatCtorInfo | Lean.Compiler.IR.Format | Std.ToFormat Lean.IR.CtorInfo | null | true |
_private.Mathlib.Data.Set.Functor.0.Set.image_coe_eq_domRestrict_image.match_1_3 | Mathlib.Data.Set.Functor | ∀ {α : Type u_2} {β : Set α} {γ : Set ↑β} {δ : Type u_1} {f : α → δ} (x : δ) (motive : x ∈ β.domRestrict f '' γ → Prop)
(x_1 : x ∈ β.domRestrict f '' γ), (∀ (w : ↑β) (h : w ∈ γ) (ha : β.domRestrict f w = x), motive ⋯) → motive x_1 | null | false |
Ordnode.mem.decidable | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → [inst : LE α] → [inst_1 : DecidableLE α] → (x : α) → (t : Ordnode α) → Decidable (x ∈ t) | null | true |
Complex.one_add_cpow_hasFPowerSeriesAt_zero | Mathlib.Analysis.Analytic.Binomial | ∀ {a : ℂ}, HasFPowerSeriesAt (fun x => (1 + x) ^ a) (binomialSeries ℂ a) 0 | null | true |
OrderHom.curry._proof_4 | Mathlib.Order.Hom.Basic | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
(f : α × β →o γ) (x x_1 : α), x ≤ x_1 → ∀ (x_2 : β), f (x, x_2) ≤ f (x_1, x_2) | null | false |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.Solvers.mergeTerms.go.match_1.eq_1 | Lean.Meta.Tactic.Grind.Types | ∀ (motive : Lean.Meta.Grind.SolverTerms × Lean.Meta.Grind.PendingSolverPropagationsData✝ → Sort u_1)
(s : Lean.Meta.Grind.SolverTerms) (p : Lean.Meta.Grind.PendingSolverPropagationsData✝)
(h_1 : (s : Lean.Meta.Grind.SolverTerms) → (p : Lean.Meta.Grind.PendingSolverPropagationsData✝) → motive (s, p)),
(match (s, p... | null | true |
CircleDeg1Lift.instLattice._proof_4 | Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | ∀ (f : CircleDeg1Lift) (x : ℝ), f x ≤ f x | null | false |
Lean.Lsp.DiagnosticWith.relatedInformation?._default | Lean.Data.Lsp.Diagnostics | {α : Type} → Option (Array Lean.Lsp.DiagnosticRelatedInformation) | null | false |
Subgroup.closure_pi | Mathlib.Algebra.Group.Subgroup.Finite | ∀ {η : Type u_2} {f : η → Type u_3} [inst : (i : η) → Group (f i)] [Finite η] {s : (i : η) → Set (f i)},
(∀ (i : η), 1 ∈ s i) →
Subgroup.closure (Set.univ.pi fun i => s i) = Subgroup.pi Set.univ fun i => Subgroup.closure (s i) | null | true |
_private.Lean.Environment.0.Lean.Environment.realizeValue.unsafe_impl_11 | Lean.Environment | {α : Type u_1} → [inst : BEq α] → [inst_1 : Hashable α] → NonScalar → Lean.PHashMap α (Task Dynamic) | null | true |
MeasureTheory.MemLp.toLp | Mathlib.MeasureTheory.Function.LpSpace.Basic | {α : Type u_1} →
{E : Type u_4} →
{m : MeasurableSpace α} →
{p : ENNReal} →
{μ : MeasureTheory.Measure α} →
[inst : NormedAddCommGroup E] → (f : α → E) → MeasureTheory.MemLp f p μ → ↥(MeasureTheory.Lp E p μ) | make an element of Lp from a function verifying `MemLp` | true |
Lean.Syntax.SepArray.casesOn | Init.Prelude | {sep : String} →
{motive : Lean.Syntax.SepArray sep → Sort u} →
(t : Lean.Syntax.SepArray sep) →
((elemsAndSeps : Array Lean.Syntax) → motive { elemsAndSeps := elemsAndSeps }) → motive t | null | false |
ProofWidgets.MakeEditLinkProps.recOn | ProofWidgets.Component.MakeEditLink | {motive : ProofWidgets.MakeEditLinkProps → Sort u} →
(t : ProofWidgets.MakeEditLinkProps) →
((edit : Lean.Lsp.TextDocumentEdit) →
(newSelection? : Option Lean.Lsp.Range) →
(title? : Option String) → motive { edit := edit, newSelection? := newSelection?, title? := title? }) →
motive t | null | false |
Std.ExtDHashMap.filter_eq_self_iff | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α]
{f : (a : α) → β a → Bool}, Std.ExtDHashMap.filter f m = m ↔ ∀ (k : α) (h : k ∈ m), f k (m.get k h) = true | null | true |
CategoryTheory.ShortComplex.zero_assoc | Mathlib.Algebra.Homology.ShortComplex.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(self : CategoryTheory.ShortComplex C) {Z : C} (h : self.X₃ ⟶ Z),
CategoryTheory.CategoryStruct.comp self.f (CategoryTheory.CategoryStruct.comp self.g h) =
CategoryTheory.CategoryStruct.comp 0 h | the composition of the two given morphisms is zero | true |
Function.Injective.extend_injOn | Mathlib.Data.Set.Restrict | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β} {g : α → γ} {j : β → γ},
Function.Injective f → Function.Injective g → Set.InjOn (Function.extend f g j) (Set.range f) | If `f` and `g` are injective, then `extend f g j` is injective on the range of `f`. | true |
ArithmeticFunction.ppow_one | Mathlib.NumberTheory.ArithmeticFunction.Zeta | ∀ {R : Type u_1} [inst : Semiring R] {f : ArithmeticFunction R}, f.ppow 1 = f | null | true |
Std.DHashMap.Const.get?_inter_of_not_mem_left | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.DHashMap α fun x => β} [EquivBEq α]
[LawfulHashable α] {k : α}, k ∉ m₁ → Std.DHashMap.Const.get? (m₁.inter m₂) k = none | null | true |
contMDiffWithinAt_pi_space | Mathlib.Geometry.Manifold.ContMDiff.Constructions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {s : Set M} {x : M} {n : WithTop ℕ∞} {ι... | **Alias** of `contMDiffWithinAt_pi_module_iff`. | true |
Equiv.semigroup | Mathlib.Algebra.Group.TransferInstance | {α : Type u_2} → {β : Type u_3} → α ≃ β → [Semigroup β] → Semigroup α | Transfer `Semigroup` across an `Equiv` | true |
Quaternion.mul_coe_eq_smul | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} [inst : CommRing R] (r : R) (a : Quaternion R), a * ↑r = r • a | null | true |
List.mapM'.eq_def | Init.Data.List.Monadic | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [inst : Monad m] (f : α → m β) (x : List α),
List.mapM' f x =
match x with
| [] => pure []
| a :: l => do
let __do_lift ← f a
let __do_lift_1 ← List.mapM' f l
pure (__do_lift :: __do_lift_1) | null | true |
Batteries.Tactic.DeclCache.casesOn | Batteries.Util.Cache | {α : Type} →
{motive : Batteries.Tactic.DeclCache α → Sort u} →
(t : Batteries.Tactic.DeclCache α) →
((cache : Batteries.Tactic.Cache α) →
(addDecl addLibraryDecl : Lean.Name → Lean.ConstantInfo → α → Lean.MetaM α) →
motive { cache := cache, addDecl := addDecl, addLibraryDecl := addLib... | null | false |
CategoryTheory.MonoidalCategory.MonoidalRightAction.oppositeRightAction_actionUnitIso | Mathlib.CategoryTheory.Monoidal.Action.Opposites | ∀ (C : Type u_1) (D : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{v_2, u_2} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalRightAction C D] (x : Dᵒᵖ),
CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionU... | null | true |
Bool.linearOrder._proof_9 | Mathlib.Data.Bool.Basic | ∀ (a b : Bool), compare a b = compareOfLessAndEq a b | null | false |
CategoryTheory.Pretriangulated.instSplitEpiCategory | Mathlib.CategoryTheory.Triangulated.Pretriangulated | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [hC : CategoryTheory.Pretriangulated C],
CategoryTheory.SplitEpi... | null | true |
CategoryTheory.SimplicialObject.Truncated._aux_Mathlib_AlgebraicTopology_SimplicialObject_Basic___macroRules_CategoryTheory_SimplicialObject_Truncated_mkNotation_1 | Mathlib.AlgebraicTopology.SimplicialObject.Basic | Lean.Macro | null | false |
Lean.Compiler.LCNF.ReduceJpArity.reduce | Lean.Compiler.LCNF.ReduceJpArity | Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure →
Lean.Compiler.LCNF.ReduceJpArity.ReduceM (Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure) | null | true |
TensorProduct.leftModule | Mathlib.LinearAlgebra.TensorProduct.Defs | {R : Type u_1} →
{R'' : Type u_3} →
[inst : CommSemiring R] →
[inst_1 : Semiring R''] →
{M : Type u_5} →
{N : Type u_6} →
[inst_2 : AddCommMonoid M] →
[inst_3 : AddCommMonoid N] →
[inst_4 : Module R'' M] →
[inst_5 : Module R M] →
... | null | true |
_private.Init.Data.ByteArray.Lemmas.0.ByteArray.append_right_inj._simp_1_1 | Init.Data.ByteArray.Lemmas | ∀ {x y : ByteArray}, (x = y) = (x.data = y.data) | null | false |
QuotientGroup.comapMk'OrderIso._proof_2 | Mathlib.GroupTheory.QuotientGroup.Basic | ∀ {G : Type u_1} [inst : Group G] (N : Subgroup G) [hn : N.Normal] (x : ↑(Set.Ici N)),
N ≤ Subgroup.comap (QuotientGroup.mk' N) (Subgroup.map (QuotientGroup.mk' N) ↑x) | null | false |
_private.Mathlib.Order.ConditionallyCompleteLattice.Indexed.0.cbiInf_of_not_bddBelow.match_1_1 | Mathlib.Order.ConditionallyCompleteLattice.Indexed | ∀ {α : Type u_1} {ι : Sort u_2} {p : ι → Prop} {f : (i : ι) → p i → α} (x : α)
(motive : (x ∈ Set.range fun i => f ↑i ⋯) → Prop) (x_1 : x ∈ Set.range fun i => f ↑i ⋯),
(∀ (x_2 : Subtype p) (hx : (fun i => f ↑i ⋯) x_2 = x), motive ⋯) → motive x_1 | null | false |
Std.ExtHashSet.get?_eq_some_of_contains | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashSet α} [inst : LawfulBEq α] {k : α},
m.contains k = true → m.get? k = some k | null | true |
RingCon.instZeroQuotient | Mathlib.RingTheory.Congruence.Defs | {R : Type u_1} → [inst : AddZeroClass R] → [inst_1 : Mul R] → (c : RingCon R) → Zero c.Quotient | null | true |
AlgebraicGeometry.Scheme.Modules.overMapCompOverEquiv._proof_12 | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {X : AlgebraicGeometry.Scheme} {U V : X.Opens} (f : V ⟶ U),
(AlgebraicGeometry.Scheme.Hom.opensFunctor (X.homOfLE ⋯)).IsContinuous (Opens.grothendieckTopology ↥↑V)
(Opens.grothendieckTopology ↥↑U) | null | false |
OrderDual.ofDual_inj | Mathlib.Order.OrderDual | ∀ {α : Type u_1} {a b : αᵒᵈ}, OrderDual.ofDual a = OrderDual.ofDual b ↔ a = b | null | true |
Lean.DefinitionVal._sizeOf_inst | Lean.Declaration | SizeOf Lean.DefinitionVal | null | false |
CategoryTheory.Limits.splitEpiOfIdempotentOfIsColimitCofork.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] {X : C} {f : X ⟶ X}
(hf : CategoryTheory.CategoryStruct.comp f f = f)
{c : CategoryTheory.Limits.Cofork (CategoryTheory.CategoryStruct.id X) f} (i : CategoryTheory.Limits.IsColimit c),
CategoryTheory.Limits.splitEpiOfIdempotentOfIsColimitCofork C hf i =
... | null | true |
IterateMulAct.mk._flat_ctor | Mathlib.GroupTheory.GroupAction.IterateAct | {α : Type u_1} → {f : α → α} → ℕ → IterateMulAct f | null | false |
_private.Lean.Meta.LetToHave.0.Lean.Meta.LetToHave.visitLambdaLet.go._sparseCasesOn_1 | Lean.Meta.LetToHave | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam binderName binderType body binderInfo)) →
((declName : Lean.Name) →
(type value body : Lean.Expr) → (nondep : Bool)... | null | false |
Lean.Meta.Grind.Arith.Linear.RingEqCnstrProof.symm | Lean.Meta.Tactic.Grind.Arith.Linear.Types | Lean.Meta.Grind.Arith.Linear.RingEqCnstr → Lean.Meta.Grind.Arith.Linear.RingEqCnstrProof | null | true |
_private.Init.Data.Range.Polymorphic.SInt.0.ISize.instUpwardEnumerable._proof_3 | Init.Data.Range.Polymorphic.SInt | ∀ (n : ℕ) (i : ISize), i.toInt + ↑n ≤ ISize.maxValueSealed✝.toInt → i.toInt + ↑n ≤ ISize.maxValue.toInt | null | false |
RingHom.HasEqualizers.createsLimitsWalkingParallelPair | Mathlib.Algebra.Category.Ring.Under.Property | {Q : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop} →
(RingHom.RespectsIso fun {R S} [CommRing R] [CommRing S] => Q) →
(RingHom.HasEqualizers fun {R S} [CommRing R] [CommRing S] => Q) →
(R : CommRingCat) →
CategoryTheory.CreatesLimitsOfShape CategoryTheory.Limits.Wa... | If `Q` is stable under equalizers, the inclusion from the subcategory of `Under R` defined
by `Q` creates equalizers. | true |
add_pow_eq_mul_pow_add_pow_div_char | Mathlib.Algebra.CharP.Lemmas | ∀ {R : Type u_1} [inst : CommSemiring R] (x y : R) (p n : ℕ) [hp : Fact (Nat.Prime p)] [CharP R p],
(x + y) ^ n = (x + y) ^ (n % p) * (x ^ p + y ^ p) ^ (n / p) | null | true |
_private.Batteries.Data.BinaryHeap.WF.0.Batteries.BinaryHeap.WF.Below.swap._proof_1_5 | Batteries.Data.BinaryHeap.WF | ∀ {α : Type u_1} {sz : ℕ} {a : Vector α sz} (w : Fin sz), 2 * ↑w + 3 ≤ sz → 2 * ↑w + 2 < sz | null | false |
NNRat.cast_inj | Mathlib.Data.Rat.Cast.CharZero | ∀ {α : Type u_1} [inst : DivisionSemiring α] [CharZero α] {p q : ℚ≥0}, ↑p = ↑q ↔ p = q | null | true |
List.isPrefixOfAux_toArray_succ'._proof_2 | Init.Data.List.ToArray | ∀ {α : Type u_1} (l₁ l₂ : List α),
l₁.length ≤ l₂.length → ∀ (i : ℕ), (List.drop (i + 1) l₁).toArray.size ≤ (List.drop (i + 1) l₂).toArray.size | null | false |
groupHomology.shortComplexH2_g | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u, u, u} k G),
(groupHomology.shortComplexH2 A).g = groupHomology.d₂₁ A | null | true |
_private.Std.Data.String.ToNat.0.String.Slice.isNat_iff'._simp_1_24 | Std.Data.String.ToNat | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
Aesop.Frontend.BuilderOption.rec | Aesop.Frontend.RuleExpr | {motive : Aesop.Frontend.BuilderOption → Sort u} →
((names : Array Lean.Name) → motive (Aesop.Frontend.BuilderOption.immediate names)) →
((imode : Aesop.IndexingMode) → motive (Aesop.Frontend.BuilderOption.index imode)) →
((stx : Lean.Term) → motive (Aesop.Frontend.BuilderOption.pattern stx)) →
((pa... | null | false |
_private.Mathlib.Algebra.Module.LocalizedModule.Submodule.0.IsLocalizedModule.toLocalizedQuotient'._simp_2 | Mathlib.Algebra.Module.LocalizedModule.Submodule | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (p : Submodule R M)
{x y : M}, (Submodule.Quotient.mk x = Submodule.Quotient.mk y) = (x - y ∈ p) | null | false |
Std.TreeMap.Raw.WF.insertManyIfNewUnit | Std.Data.TreeMap.Raw.WF | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] {ρ : Type u_1} [inst : ForIn Id ρ α] {l : ρ}
{t : Std.TreeMap.Raw α Unit cmp}, t.WF → (t.insertManyIfNewUnit l).WF | null | true |
antilipschitzWith_inv_iff | Mathlib.Analysis.Normed.Group.Uniform | ∀ {α : Type u_4} {E : Type u_5} [inst : SeminormedCommGroup E] [inst_1 : PseudoEMetricSpace α] {K : NNReal} {f : α → E},
AntilipschitzWith K f⁻¹ ↔ AntilipschitzWith K f | null | true |
Pi.single_mul_right | Mathlib.Algebra.GroupWithZero.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → MulZeroClass (α i)] [inst_1 : DecidableEq ι] {i : ι}
{f : (i : ι) → α i} (a : α i), Pi.single i (f i * a) = f * Pi.single i a | null | true |
NNRat.instMetricSpace._proof_24 | Mathlib.Topology.Instances.Rat | ∀ {x y : ℚ≥0}, dist x y = 0 → x = y | null | false |
CategoryTheory.Bicategory.Adj.Hom₂.ctorIdx | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | {B : Type u} →
{inst : CategoryTheory.Bicategory B} →
{a b : CategoryTheory.Bicategory.Adj B} → {α β : a ⟶ b} → CategoryTheory.Bicategory.Adj.Hom₂ α β → ℕ | null | false |
ByteArray.Iterator.hasNext.eq_1 | Init.Data.ByteArray.Basic | ∀ (arr : ByteArray) (i : ℕ), { array := arr, idx := i }.hasNext = decide (i < arr.size) | null | true |
AddSubgroup.map_center_le_center | Mathlib.GroupTheory.Subgroup.Center | ∀ {G : Type u_1} {H : Type u_2} [inst : AddGroup G] [inst_1 : AddGroup H] {F : Type u_3} [inst_2 : FunLike F G H]
[inst_3 : AddMonoidHomClass F G H] {f : F},
Function.Surjective ⇑f → AddSubgroup.map (↑f) (AddSubgroup.center G) ≤ AddSubgroup.center H | null | true |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.toList_rio_add_add_eq_append._proof_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m : ℕ}, ¬0 ≤ m → False | null | false |
Subgroup.fintypeBot | Mathlib.Algebra.Group.Subgroup.Finite | {G : Type u_1} → [inst : Group G] → Fintype ↥⊥ | null | true |
LE.le.isOpenPosMeasure | Mathlib.MeasureTheory.Measure.OpenPos | ∀ {X : Type u_1} [inst : TopologicalSpace X] {m : MeasurableSpace X} {μ ν : MeasureTheory.Measure X}
[μ.IsOpenPosMeasure], μ ≤ ν → ν.IsOpenPosMeasure | null | true |
Lean.Grind.GrobnerConfig.locals._inherited_default | Init.Grind.Config | Bool | null | false |
NNNorm | Mathlib.Analysis.Normed.Group.Defs | Type u_4 → Type u_4 | Auxiliary class, endowing a type `α` with a function `nnnorm : α → ℝ≥0` with notation `‖x‖₊`. | true |
FirstOrder.Language.Hom.casesOn | Mathlib.ModelTheory.Basic | {L : FirstOrder.Language} →
{M : Type w} →
{N : Type w'} →
[inst : L.Structure M] →
[inst_1 : L.Structure N] →
{motive : L.Hom M N → Sort u_1} →
(t : L.Hom M N) →
((toFun : M → N) →
(map_fun' :
∀ {n : ℕ} (f : L.Functions n) ... | null | false |
Array.step_iterFromIdxM | Std.Data.Iterators.Lemmas.Producers.Monadic.Array | ∀ {m : Type w → Type w'} [inst : Monad m] {β : Type w} {array : Array β} {pos : ℕ},
(array.iterFromIdxM m pos).step =
pure
(Std.Shrink.deflate
(if h : pos < array.size then Std.PlausibleIterStep.yield (array.iterFromIdxM m (pos + 1)) array[pos] ⋯
else Std.PlausibleIterStep.done ⋯)) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.