name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Lean.Environment.0.Lean.importModulesCore.match_3 | Lean.Environment | (motive : Option Lean.ImportedModule✝ → Sort u_1) →
(x : Option Lean.ImportedModule✝¹) →
((mod : Lean.ImportedModule✝²) → motive (some mod)) → ((x : Option Lean.ImportedModule✝³) → motive x) → motive x | false |
CategoryTheory.Mon.instSymmetricCategory.eq_1 | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.SymmetricCategory C],
CategoryTheory.Mon.instSymmetricCategory =
{ braiding := fun X Y => CategoryTheory.Mon.mkIso' (β_ X.X Y.X), braiding_naturality_right := ⋯,
braiding_natur... | true |
AddGroupNormClass.casesOn | Mathlib.Algebra.Order.Hom.Basic | {F : Type u_7} →
{α : Type u_8} →
{β : Type u_9} →
[inst : AddGroup α] →
[inst_1 : AddCommMonoid β] →
[inst_2 : PartialOrder β] →
[inst_3 : FunLike F α β] →
{motive : AddGroupNormClass F α β → Sort u} →
(t : AddGroupNormClass F α β) →
... | false |
_private.Lean.Expr.0.Lean.Expr.getForallBody._sparseCasesOn_1 | Lean.Expr | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
(Nat.hasNotBit 128 t.ctorIdx → motive t) → motive t | false |
CategoryTheory.evaluationLeftAdjoint_map_app | Mathlib.CategoryTheory.Adjunction.Evaluation | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : ∀ (a b : C), CategoryTheory.Limits.HasCoproductsOfShape (a ⟶ b) D] (c : C) {x d₂ : D} (f : x ⟶ d₂)
(x_1 : C),
((CategoryTheory.evaluationLeftAdjoint D c).map f).app x_1 =
CategoryT... | true |
Mathlib.Notation3.MatchState.getBinders | Mathlib.Util.Notation3 | Mathlib.Notation3.MatchState → Array (Lean.TSyntax `Batteries.ExtendedBinder.extBinderParenthesized) | true |
Std.Internal.IO.Async.System.UserId.toNat | Std.Internal.Async.System | Std.Internal.IO.Async.System.UserId → ℕ | true |
Lean.Server.Reference.aliases._default | Lean.Server.References | Array Lean.Lsp.RefIdent | false |
BoxIntegral.unitPartition.box_upper | Mathlib.Analysis.BoxIntegral.UnitPartition | ∀ {ι : Type u_1} (n : ℕ) [inst : NeZero n] (ν : ι → ℤ),
(BoxIntegral.unitPartition.box n ν).upper = fun i => (↑(ν i) + 1) / ↑n | true |
CategoryTheory.cocones_map_app_app | Mathlib.CategoryTheory.Limits.Cones | ∀ (J : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} J] (C : Type u₃) [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{X Y : (CategoryTheory.Functor J C)ᵒᵖ} (f : X ⟶ Y) (X_1 : C)
(a : (CategoryTheory.coyoneda.obj (Opposite.op (Opposite.unop X))).obj ((CategoryTheory.Functor.const J).obj X_1))
(X_2 : J),
(((Ca... | true |
ContinuousLinearMap.toLinearMap₁₂ | Mathlib.Topology.Algebra.Module.StrongTopology | {R : Type u_1} →
{𝕜₂ : Type u_3} →
{𝕜₃ : Type u_4} →
{E : Type u_5} →
{F : Type u_6} →
{G : Type u_7} →
[inst : Semiring R] →
[inst_1 : NormedField 𝕜₂] →
[inst_2 : NormedField 𝕜₃] →
[inst_3 : AddCommMonoid E] →
... | true |
_private.Mathlib.FieldTheory.KummerExtension.0.exists_root_adjoin_eq_top_of_isCyclic.match_1_5 | Mathlib.FieldTheory.KummerExtension | ∀ (K : Type u_2) [inst : Field K] (L : Type u_1) [inst_1 : Field L] [inst_2 : Algebra K L]
(motive : ↥(OrderDual.ofDual ⊥) → Prop) (h : ↥(OrderDual.ofDual ⊥)),
(∀ (σ' : Gal(L/K)) (hσ' : σ' ∈ OrderDual.ofDual ⊥), motive ⟨σ', hσ'⟩) → motive h | false |
FreeSemigroup.noConfusion | Mathlib.Algebra.Free | {P : Sort u_1} →
{α : Type u} →
{t : FreeSemigroup α} →
{α' : Type u} → {t' : FreeSemigroup α'} → α = α' → t ≍ t' → FreeSemigroup.noConfusionType P t t' | false |
_private.Mathlib.RingTheory.Ideal.Over.0.Ideal.Quotient.ker_stabilizerHom._simp_1_2 | Mathlib.RingTheory.Ideal.Over | ∀ {R : Type u} [inst : Ring R] {I : Ideal R} {x y : R} [inst_1 : I.IsTwoSided],
((Ideal.Quotient.mk I) x = (Ideal.Quotient.mk I) y) = (x - y ∈ I) | false |
Real.mk_zero | Mathlib.Data.Real.Basic | Real.mk 0 = 0 | true |
List.Perm.union | Batteries.Data.List.Perm | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {l₁ l₂ t₁ t₂ : List α}, l₁.Perm l₂ → t₁.Perm t₂ → (l₁ ∪ t₁).Perm (l₂ ∪ t₂) | true |
OrderIso.map_ciInf | Mathlib.Order.ConditionallyCompleteLattice.Indexed | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} [inst : ConditionallyCompleteLattice α]
[inst_1 : ConditionallyCompleteLattice β] [Nonempty ι] (e : α ≃o β) {f : ι → α},
BddBelow (Set.range f) → e (⨅ i, f i) = ⨅ i, e (f i) | true |
_private.Init.Data.String.Pattern.Basic.0.String.Slice.Pattern.ToForwardSearcher.DefaultForwardSearcher.finitenessRelation._proof_1 | Init.Data.String.Pattern.Basic | ∀ {ρ : Type} (pat : ρ) (s : String.Slice),
WellFounded (InvImage WellFoundedRelation.rel fun it => it.internalState.currPos) | false |
Std.Sat.CNF.sat_empty._simp_1 | Std.Sat.CNF.Basic | ∀ {α : Type u_1} {assign : α → Bool}, Std.Sat.CNF.Sat assign Std.Sat.CNF.empty = True | false |
Lean.Core.State.messages | Lean.CoreM | Lean.Core.State → Lean.MessageLog | true |
List.reflBEq_iff | Init.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α], ReflBEq (List α) ↔ ReflBEq α | true |
_private.Mathlib.Combinatorics.Matroid.Loop.0.Matroid.not_isNonloop_iff_closure._simp_1_1 | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} {M : Matroid α} {e : α}, M.IsLoop e = (M.closure {e} = M.loops ∧ e ∈ M.E) | false |
CategoryTheory.Limits.IsLimit.conePointsIsoOfNatIso_inv_comp_assoc | Mathlib.CategoryTheory.Limits.IsLimit | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F G : CategoryTheory.Functor J C} {s : CategoryTheory.Limits.Cone F} {t : CategoryTheory.Limits.Cone G}
(P : CategoryTheory.Limits.IsLimit s) (Q : CategoryTheory.Limits.IsLimit t) (w : F ≅ G) (j ... | true |
Std.ExtTreeSet.mem_insertMany_list | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] [inst_1 : BEq α]
[Std.LawfulBEqCmp cmp] {l : List α} {k : α}, k ∈ t.insertMany l ↔ k ∈ t ∨ l.contains k = true | true |
Lean.Grind.AC.Seq.endsWithVar_k_var | Init.Grind.AC | ∀ (y x : Lean.Grind.AC.Var), (Lean.Grind.AC.Seq.var y).endsWithVar_k x = (x == y) | true |
Aesop.SimpTheorems.foldSimpEntries | Aesop.Util.Basic | {σ : Type u_1} → (σ → Lean.Meta.SimpEntry → σ) → σ → Lean.Meta.SimpTheorems → σ | true |
_private.Mathlib.Topology.Algebra.MetricSpace.Lipschitz.0.LocallyLipschitzOn.exists_lipschitzOnWith_of_compact.match_1_5 | Mathlib.Topology.Algebra.MetricSpace.Lipschitz | ∀ {α : Type u_1} {β : Type u_2} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {f : α → β} {s : Set α}
(ε : (x : α) → x ∈ s → ℝ) (x : α) (hx : x ∈ s)
(motive : BddAbove ((fun y => dist (f x) (f y) / dist x y) '' (s \ Metric.ball x (ε x hx))) → Prop)
(x_1 : BddAbove ((fun y => dist (f x) (f y) / dist ... | false |
IntervalIntegrable.iff_comp_neg._auto_1 | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | Lean.Syntax | false |
Ideal.ramificationIdx_le_finrank | Mathlib.NumberTheory.RamificationInertia.Basic | ∀ {R : Type u} [inst : CommRing R] (S : Type v) [inst_1 : CommRing S] [inst_2 : Algebra R S] [IsDedekindDomain S]
(K : Type u_1) (L : Type u_2) [inst_4 : Field K] [inst_5 : Field L] [IsDedekindDomain R] [inst_7 : Algebra R K]
[IsFractionRing R K] [inst_9 : Algebra S L] [IsFractionRing S L] [inst_11 : Algebra K L] [... | true |
LieAlgebra.Orthogonal.JD | Mathlib.Algebra.Lie.Classical | (l : Type u_4) → (R : Type u₂) → [DecidableEq l] → [CommRing R] → Matrix (l ⊕ l) (l ⊕ l) R | true |
εNFA.stepSet | Mathlib.Computability.EpsilonNFA | {α : Type u} → {σ : Type v} → εNFA α σ → Set σ → α → Set σ | true |
CategoryTheory.Subobject.inf_comp_right_assoc | Mathlib.CategoryTheory.Subobject.Lattice | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C] {A : C}
(f g : CategoryTheory.Subobject A) {Z : C} (h : A ⟶ Z),
CategoryTheory.CategoryStruct.comp ((f ⊓ g).ofLE g ⋯) (CategoryTheory.CategoryStruct.comp g.arrow h) =
CategoryTheory.CategoryStruct.comp (f... | true |
CategoryTheory.Functor.hasPointwiseRightKanExtensionAt_of_equivalence | Mathlib.CategoryTheory.Functor.KanExtension.Pointwise | ∀ {C : Type u_1} {D : Type u_2} {D' : Type u_3} {H : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_3, u_3} D']
[inst_3 : CategoryTheory.Category.{v_4, u_4} H] (L : CategoryTheory.Functor C D) (L' : CategoryTheory.Functor ... | true |
Turing.TM2to1.StAct.push.sizeOf_spec | Mathlib.Computability.TuringMachine.StackTuringMachine | ∀ {K : Type u_1} {Γ : K → Type u_2} {σ : Type u_4} {k : K} [inst : SizeOf K] [inst_1 : (a : K) → SizeOf (Γ a)]
[inst_2 : SizeOf σ] (a : σ → Γ k), sizeOf (Turing.TM2to1.StAct.push a) = 1 | true |
Std.Do.SPred.and_or_elim_l | Std.Do.SPred.DerivedLaws | ∀ {σs : List (Type u)} {P Q R T : Std.Do.SPred σs}, (P ∧ R ⊢ₛ T) → (Q ∧ R ⊢ₛ T) → (P ∨ Q) ∧ R ⊢ₛ T | true |
differentiableWithinAt_sub_const_iff | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : 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}
{x : E} {s : Set E} (c : F), DifferentiableWithinAt 𝕜 (fun y => f y - c) s x ↔ DifferentiableWithin... | true |
Continuous.measurable | Mathlib.MeasureTheory.Constructions.BorelSpace.Basic | ∀ {α : Type u_1} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] [OpensMeasurableSpace α]
[inst_3 : TopologicalSpace γ] [inst_4 : MeasurableSpace γ] [BorelSpace γ] {f : α → γ}, Continuous f → Measurable f | true |
CategoryTheory.Discrete.functor_obj_eq_as | Mathlib.CategoryTheory.Discrete.Basic | ∀ {C : Type u₂} [inst : CategoryTheory.Category.{v₂, u₂} C] {I : Type u₁} (F : I → C) (X : CategoryTheory.Discrete I),
(CategoryTheory.Discrete.functor F).obj X = F X.as | true |
Lean.IR.IRType._sizeOf_3_eq | Lean.Compiler.IR.Basic | ∀ (x : List Lean.IR.IRType), Lean.IR.IRType._sizeOf_3 x = sizeOf x | false |
CategoryTheory.Under.isLeftAdjoint_post | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(X : T) (F : CategoryTheory.Functor T D) [F.IsLeftAdjoint], (CategoryTheory.Under.post F).IsLeftAdjoint | true |
Lean.Parser.Term.show._regBuiltin.Lean.Parser.Term.show.parenthesizer_11 | Lean.Parser.Term | IO Unit | false |
_private.Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer.0.CategoryTheory.Limits.WalkingMulticospan.functor_ext._proof_1_1 | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {J : CategoryTheory.Limits.MulticospanShape} {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C]
{F G : CategoryTheory.Functor (CategoryTheory.Limits.WalkingMulticospan J) C},
(∀ (i : J.L),
F.obj (CategoryTheory.Limits.WalkingMulticospan.left i) =
G.obj (CategoryTheory.Limits.WalkingMultico... | false |
groupHomology.cyclesOfIsCycle₁._proof_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G A : Type u_1} [inst : CommRing k] [inst_1 : Group G] [inst_2 : AddCommGroup A] [inst_3 : Module k A]
[inst_4 : DistribMulAction G A] [inst_5 : SMulCommClass G k A] (x : G →₀ A),
groupHomology.IsCycle₁ x → x ∈ groupHomology.cycles₁ (Rep.ofDistribMulAction k G A) | false |
Finset.sum_indicator_subset | Mathlib.Algebra.BigOperators.Group.Finset.Indicator | ∀ {ι : Type u_1} {β : Type u_4} [inst : AddCommMonoid β] (f : ι → β) {s t : Finset ι},
s ⊆ t → ∑ i ∈ t, (↑s).indicator f i = ∑ i ∈ s, f i | true |
SupHom.mk.sizeOf_spec | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_6} {β : Type u_7} [inst : Max α] [inst_1 : Max β] [inst_2 : SizeOf α] [inst_3 : SizeOf β] (toFun : α → β)
(map_sup' : ∀ (a b : α), toFun (a ⊔ b) = toFun a ⊔ toFun b), sizeOf { toFun := toFun, map_sup' := map_sup' } = 1 | true |
KStar | Mathlib.Algebra.Order.Kleene | Type u_5 → Type u_5 | true |
HahnSeries.support_embDomain_subset | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {Γ' : Type u_2} {R : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] [inst_2 : PartialOrder Γ']
{f : Γ ↪o Γ'} {x : HahnSeries Γ R}, (HahnSeries.embDomain f x).support ⊆ ⇑f '' x.support | true |
Matrix.twoBlockTriangular_det | Mathlib.LinearAlgebra.Matrix.Block | ∀ {m : Type u_3} {R : Type v} [inst : CommRing R] [inst_1 : DecidableEq m] [inst_2 : Fintype m] (M : Matrix m m R)
(p : m → Prop) [inst_3 : DecidablePred p],
(∀ (i : m), ¬p i → ∀ (j : m), p j → M i j = 0) →
M.det = (M.toSquareBlockProp p).det * (M.toSquareBlockProp fun i => ¬p i).det | true |
Finset.intervalGapsWithin.snd.congr_simp | Mathlib.Order.Interval.Finset.Gaps | ∀ {α : Type u_1} [inst : LinearOrder α] (F F_1 : Finset (α × α)) (e_F : F = F_1) {k : ℕ} (h : F.card = k) (b b_1 : α),
b = b_1 →
∀ (i i_1 : Fin (k + 1)),
i = i_1 → Finset.intervalGapsWithin.snd F h b i = Finset.intervalGapsWithin.snd F_1 ⋯ b_1 i_1 | true |
Mathlib.Tactic.Sat.buildProof.match_5 | Mathlib.Tactic.Sat.FromLRAT | (motive : Option Lean.Expr → Sort u_1) →
(x : Option Lean.Expr) → (Unit → motive none) → ((a : Lean.Expr) → motive (some a)) → motive x | false |
ClosedSubgroup.instSetLike | Mathlib.Topology.Algebra.Group.ClosedSubgroup | (G : Type u) → [inst : Group G] → [inst_1 : TopologicalSpace G] → SetLike (ClosedSubgroup G) G | true |
_private.Mathlib.Analysis.SpecialFunctions.Artanh.0.Real.strictMonoOn_artanh._proof_1_4 | Mathlib.Analysis.SpecialFunctions.Artanh | ∀ x ∈ Set.Ioo (-1) 1, 0 ≤ 1 - x | false |
CategoryTheory.Localization.Construction.natTransExtension | Mathlib.CategoryTheory.Localization.Construction | {C : Type uC} →
[inst : CategoryTheory.Category.{uC', uC} C] →
{W : CategoryTheory.MorphismProperty C} →
{D : Type uD} →
[inst_1 : CategoryTheory.Category.{uD', uD} D] →
{F₁ F₂ : CategoryTheory.Functor W.Localization D} → (W.Q.comp F₁ ⟶ W.Q.comp F₂) → (F₁ ⟶ F₂) | true |
Computability.instDecidableEqΓ'.decEq._proof_6 | Mathlib.Computability.Encoding | ¬Computability.Γ'.blank = Computability.Γ'.comma | false |
_private.Init.Data.String.Pattern.Basic.0.String.Slice.Pattern.ToBackwardSearcher.DefaultBackwardSearcher.finitenessRelation._proof_2 | Init.Data.String.Pattern.Basic | ∀ {ρ : Type} (pat : ρ) (s : String.Slice) [inst : String.Slice.Pattern.BackwardPattern pat]
[String.Slice.Pattern.StrictBackwardPattern pat] {it it' : Std.IterM Id (String.Slice.Pattern.SearchStep s)},
it'.IsPlausibleSuccessorOf it → InvImage WellFoundedRelation.rel (fun it => it.internalState.currPos.down) it' it | false |
ModuleFilterBasis.smul_right' | Mathlib.Topology.Algebra.FilterBasis | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : TopologicalSpace R] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] (self : ModuleFilterBasis R M) (m₀ : M) {U : Set M},
U ∈ self.sets → ∀ᶠ (x : R) in nhds 0, x • m₀ ∈ U | true |
Homeomorph.isCompact_image | Mathlib.Topology.Homeomorph.Lemmas | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {s : Set X} (h : X ≃ₜ Y),
IsCompact (⇑h '' s) ↔ IsCompact s | true |
topologicalNilradical._proof_1 | Mathlib.Topology.Algebra.TopologicallyNilpotent | ∀ (R : Type u_1) [inst : TopologicalSpace R] [inst_1 : CommRing R], IsTopologicallyNilpotent 0 | false |
Std.Rio.length_iter | Std.Data.Iterators.Lemmas.Producers.Range | ∀ {α : Type u_1} [inst : Std.PRange.Least? α] [inst_1 : LT α] [inst_2 : DecidableLT α]
[inst_3 : Std.PRange.UpwardEnumerable α] [inst_4 : Std.PRange.LawfulUpwardEnumerableLT α] [Std.Rxo.IsAlwaysFinite α]
[inst_6 : Std.PRange.LawfulUpwardEnumerable α] [inst_7 : Std.Rxo.HasSize α] [Std.Rxo.LawfulHasSize α] {r : Std.R... | true |
Std.Iter.filterMapWithPostcondition_eq_toIter_filterMapWithPostcondition_toIterM | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {α β γ : Type w} [inst : Std.Iterator α Id β] {it : Std.Iter β} {m : Type w → Type w'} [inst_1 : Monad m]
{f : β → Std.Iterators.PostconditionT m (Option γ)},
Std.Iter.filterMapWithPostcondition f it = Std.IterM.filterMapWithPostcondition f it.toIterM | true |
Char.reduceToString._regBuiltin.Char.reduceToString.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char.2368443037._hygCtx._hyg.18 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char | IO Unit | false |
nontrivial_iff_exists_ne | Mathlib.Logic.Nontrivial.Defs | ∀ {α : Type u_1} (x : α), Nontrivial α ↔ ∃ y, y ≠ x | true |
instDecidableEqNum.decEq._proof_4 | Mathlib.Data.Num.Basic | ∀ (a : PosNum), ¬Num.pos a = Num.zero | false |
Lean.Meta.MVarRenaming | Lean.Meta.Match.MVarRenaming | Type | true |
_private.Lean.Elab.MutualDef.0.Lean.Elab.Term.typeHasRecFun.match_4 | Lean.Elab.MutualDef | (motive : Option Lean.Expr → Sort u_1) →
(occ? : Option Lean.Expr) →
((fvarId : Lean.FVarId) → motive (some (Lean.Expr.fvar fvarId))) → ((x : Option Lean.Expr) → motive x) → motive occ? | false |
CategoryTheory.Functor.PreOneHypercoverDenseData.multicospanShape_L | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | ∀ {C₀ : Type u₀} {C : Type u} [inst : CategoryTheory.Category.{v₀, u₀} C₀] [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor C₀ C} {X : C} (data : F.PreOneHypercoverDenseData X), data.multicospanShape.L = data.I₀ | true |
List.zipWith_map_left | Init.Data.List.Zip | ∀ {α : Type u_1} {β : Type u_2} {α' : Type u_3} {γ : Type u_4} {l₁ : List α} {l₂ : List β} {f : α → α'}
{g : α' → β → γ}, List.zipWith g (List.map f l₁) l₂ = List.zipWith (fun a b => g (f a) b) l₁ l₂ | true |
Lean.Lsp.CompletionItemKind.value.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | sizeOf Lean.Lsp.CompletionItemKind.value = 1 | true |
Lean.PrefixTreeNode.brecOn_3.eq | Lean.Data.PrefixTree | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {motive_1 : Lean.PrefixTreeNode α β cmp → Sort u_1}
{motive_2 : Std.TreeMap.Raw α (Lean.PrefixTreeNode α β cmp) cmp → Sort u_1}
{motive_3 : Std.DTreeMap.Raw α (fun x => Lean.PrefixTreeNode α β cmp) cmp → Sort u_1}
{motive_4 : (Std.DTreeMap.Internal.Impl α fun x... | true |
isClopen_connectedComponent | Mathlib.Topology.Connected.LocallyConnected | ∀ {α : Type u} [inst : TopologicalSpace α] [LocallyConnectedSpace α] {x : α}, IsClopen (connectedComponent x) | true |
SimpleGraph.lapMatrix_ker_basis | Mathlib.Combinatorics.SimpleGraph.LapMatrix | {V : Type u_1} →
[inst : Fintype V] →
(G : SimpleGraph V) →
[inst_1 : DecidableRel G.Adj] →
[inst_2 : DecidableEq V] →
[DecidableEq G.ConnectedComponent] →
Module.Basis G.ConnectedComponent ℝ ↥(Matrix.toLin' (SimpleGraph.lapMatrix ℝ G)).ker | true |
NONote.ofNat | Mathlib.SetTheory.Ordinal.Notation | ℕ → NONote | true |
ContinuousOpenMapClass.casesOn | Mathlib.Topology.Hom.Open | {F : Type u_6} →
{α : Type u_7} →
{β : Type u_8} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] →
[inst_2 : FunLike F α β] →
{motive : ContinuousOpenMapClass F α β → Sort u} →
(t : ContinuousOpenMapClass F α β) →
([toContinuousMapCla... | false |
Matrix.IsHermitian.charpoly_cfc_eq | Mathlib.Analysis.Matrix.HermitianFunctionalCalculus | ∀ {n : Type u_1} {𝕜 : Type u_2} [inst : RCLike 𝕜] [inst_1 : Fintype n] [inst_2 : DecidableEq n] {A : Matrix n n 𝕜}
(hA : A.IsHermitian) (f : ℝ → ℝ), (cfc f A).charpoly = ∏ i, (Polynomial.X - Polynomial.C ↑(f (hA.eigenvalues i))) | true |
compl_bihimp_self | Mathlib.Order.SymmDiff | ∀ {α : Type u_2} [inst : HeytingAlgebra α] (a : α), bihimp aᶜ a = ⊥ | true |
_private.Std.Sync.Notify.0.Std.Notify.notify.match_1 | Std.Sync.Notify | (motive : Option (Std.Notify.Consumer Unit × Std.Queue (Std.Notify.Consumer Unit)) → Sort u_1) →
(x : Option (Std.Notify.Consumer Unit × Std.Queue (Std.Notify.Consumer Unit))) →
((consumer : Std.Notify.Consumer Unit) →
(rest : Std.Queue (Std.Notify.Consumer Unit)) → motive (some (consumer, rest))) →
... | false |
instGradedAlgebraRestrictScalars._proof_3 | Mathlib.RingTheory.GradedAlgebra.Basic | ∀ {ι : Type u_2} {R : Type u_3} {A : Type u_1} [inst : DecidableEq ι] [inst_1 : AddMonoid ι] [inst_2 : CommSemiring R]
[inst_3 : Semiring A] [inst_4 : Algebra R A] (𝒜 : ι → Submodule R A) [i : GradedAlgebra 𝒜],
Function.RightInverse (⇑(DirectSum.coeAddMonoidHom 𝒜)) DirectSum.Decomposition.decompose' | false |
Aesop.UnsafeRuleInfo.successProbability | Aesop.Rule | Aesop.UnsafeRuleInfo → Aesop.Percent | true |
Lean.Parser.ppAllowUngrouped.parenthesizer | Lean.Parser.Extra | Lean.PrettyPrinter.Parenthesizer | true |
Stream'.WSeq.mem_think | Mathlib.Data.WSeq.Basic | ∀ {α : Type u} (s : Stream'.WSeq α) (a : α), a ∈ s.think ↔ a ∈ s | true |
Bitraversable.id_tsnd | Mathlib.Control.Bitraversable.Lemmas | ∀ {t : Type u → Type u → Type u} [inst : Bitraversable t] [LawfulBitraversable t] {α β : Type u} (x : t α β),
Bitraversable.tsnd pure x = pure x | true |
_private.Lean.Meta.Offset.0.Lean.Meta.getOffset | Lean.Meta.Offset | Lean.Expr → Lean.MetaM (Lean.Expr × ℕ) | true |
Lean.Meta.Grind.PendingSolverPropagations._sizeOf_inst | Lean.Meta.Tactic.Grind.Types | SizeOf Lean.Meta.Grind.PendingSolverPropagations | false |
MvPFunctor.wRec_eq | Mathlib.Data.PFunctor.Multivariate.W | ∀ {n : ℕ} (P : MvPFunctor.{u} (n + 1)) {α : TypeVec.{u} n} {C : Sort u_1}
(g : (a : P.A) → (P.drop.B a).Arrow α → (P.last.B a → P.W α) → (P.last.B a → C) → C) (a : P.A)
(f' : (P.drop.B a).Arrow α) (f : P.last.B a → P.W α), P.wRec g (P.wMk a f' f) = g a f' f fun i => P.wRec g (f i) | true |
Lean.Meta.Grind.Arith.isNatAdd? | Lean.Meta.Tactic.Grind.Arith.Util | Lean.Expr → Option (Lean.Expr × Lean.Expr) | true |
Lean.SMap.mk.injEq | Lean.Data.SMap | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] (stage₁ : Bool) (map₁ : Std.HashMap α β)
(map₂ : Lean.PHashMap α β) (stage₁_1 : Bool) (map₁_1 : Std.HashMap α β) (map₂_1 : Lean.PHashMap α β),
({ stage₁ := stage₁, map₁ := map₁, map₂ := map₂ } = { stage₁ := stage₁_1, map₁ := map₁_1, map₂ := map₂_1 }) ... | true |
Finset.mk_mem_sigmaLift | Mathlib.Data.Finset.Sigma | ∀ {ι : Type u_1} {α : ι → Type u_2} {β : ι → Type u_3} {γ : ι → Type u_4} [inst : DecidableEq ι]
(f : ⦃i : ι⦄ → α i → β i → Finset (γ i)) (i : ι) (a : α i) (b : β i) (x : γ i),
⟨i, x⟩ ∈ Finset.sigmaLift f ⟨i, a⟩ ⟨i, b⟩ ↔ x ∈ f a b | true |
DMatrix.map_zero | Mathlib.Data.Matrix.DMatrix | ∀ {m : Type u_1} {n : Type u_2} {α : m → n → Type v} [inst : (i : m) → (j : n) → Zero (α i j)] {β : m → n → Type w}
[inst_1 : (i : m) → (j : n) → Zero (β i j)] {f : ⦃i : m⦄ → ⦃j : n⦄ → α i j → β i j},
(∀ (i : m) (j : n), f 0 = 0) → DMatrix.map 0 f = 0 | true |
List.continuous_prod | Mathlib.Topology.List | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : MulOneClass α] [ContinuousMul α], Continuous List.prod | true |
WeierstrassCurve.preΨ₄._proof_1 | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic | (4 + 1).AtLeastTwo | false |
MDifferentiableAt.prodMap | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : 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] {E' : Type u_5} [inst_6 : NormedAddComm... | true |
AddChar.starComp_apply | Mathlib.NumberTheory.LegendreSymbol.AddCharacter | ∀ {R : Type u_1} [inst : CommRing R], 0 < ringChar R → ∀ {φ : AddChar R ℂ} (a : R), (starRingEnd ℂ) (φ a) = φ⁻¹ a | true |
Lean.Compiler.LCNF.UnreachableBranches.Value.bot.elim | Lean.Compiler.LCNF.ElimDeadBranches | {motive_1 : Lean.Compiler.LCNF.UnreachableBranches.Value → Sort u} →
(t : Lean.Compiler.LCNF.UnreachableBranches.Value) →
t.ctorIdx = 0 → motive_1 Lean.Compiler.LCNF.UnreachableBranches.Value.bot → motive_1 t | false |
Set.mem_vadd_set_iff_neg_vadd_mem | Mathlib.Algebra.Group.Action.Pointwise.Set.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : AddGroup α] [inst_1 : AddAction α β] {A : Set β} {a : α} {x : β},
x ∈ a +ᵥ A ↔ -a +ᵥ x ∈ A | true |
Lean.SyntaxNodeKinds | Init.Prelude | Type | true |
WeierstrassCurve.Projective.polynomial.eq_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic | ∀ {R : Type r} [inst : CommRing R] (W' : WeierstrassCurve.Projective R),
W'.polynomial =
MvPolynomial.X 1 ^ 2 * MvPolynomial.X 2 +
MvPolynomial.C W'.a₁ * MvPolynomial.X 0 * MvPolynomial.X 1 * MvPolynomial.X 2 +
MvPolynomial.C W'.a₃ * MvPolynomial.X 1 * MvPolynomial.X 2 ^ 2 -
(MvPolynomial.... | true |
ULift.instLinearOrder._proof_3 | Mathlib.Order.Lattice | ∀ {α : Type u_2} [inst : LinearOrder α] (a b : ULift.{u_1, u_2} α), (min a b).down = min a.down b.down | false |
Std.DTreeMap.Internal.Impl.Equiv.constModify | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α],
t₁.WF →
t₂.WF →
t₁.Equiv t₂ →
∀ {k : α} {f : β → β},
(Std.DTreeMap.Internal.Impl.Const.modify k f t₁).Equiv (Std.DTreeMap.Internal.Impl.Const.modify k f t₂) | true |
nnnorm_eq_zero' | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_5} [inst : NormedGroup E] {a : E}, ‖a‖₊ = 0 ↔ a = 1 | true |
UInt16.toNat_xor | Init.Data.UInt.Bitwise | ∀ (a b : UInt16), (a ^^^ b).toNat = a.toNat ^^^ b.toNat | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.