name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
PiTensorProduct.mapMultilinear_apply | Mathlib.LinearAlgebra.PiTensorProduct | ∀ {ι : Type u_1} (R : Type u_4) [inst : CommSemiring R] (s : ι → Type u_7) [inst_1 : (i : ι) → AddCommMonoid (s i)]
[inst_2 : (i : ι) → Module R (s i)] (t : ι → Type u_11) [inst_3 : (i : ι) → AddCommMonoid (t i)]
[inst_4 : (i : ι) → Module R (t i)] (f : (i : ι) → s i →ₗ[R] t i),
(PiTensorProduct.mapMultilinear R s t) f = PiTensorProduct.map f | true |
«term_=_» | Init.Notation | Lean.TrailingParserDescr | true |
CategoryTheory.Over.prodLeftIsoPullback_hom_fst_assoc | Mathlib.CategoryTheory.Limits.Constructions.Over.Products | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} (Y Z : CategoryTheory.Over X)
[inst_1 : CategoryTheory.Limits.HasPullback Y.hom Z.hom] [inst_2 : CategoryTheory.Limits.HasBinaryProduct Y Z]
{Z_1 : C} (h : Y.left ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (Y.prodLeftIsoPullback Z).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst Y.hom Z.hom) h) =
CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.fst.left h | true |
_private.Init.Data.List.Perm.0.List.reverse_perm.match_1_1 | Init.Data.List.Perm | ∀ {α : Type u_1} (motive : List α → Prop) (x : List α),
(∀ (a : Unit), motive []) → (∀ (a : α) (l : List α), motive (a :: l)) → motive x | false |
Matrix.det_of_mem_unitary | Mathlib.LinearAlgebra.UnitaryGroup | ∀ {n : Type u} [inst : DecidableEq n] [inst_1 : Fintype n] {α : Type v} [inst_2 : CommRing α] [inst_3 : StarRing α]
{A : Matrix n n α}, A ∈ Matrix.unitaryGroup n α → A.det ∈ unitary α | true |
instAB4AddCommGrpCat | Mathlib.Algebra.Category.Grp.AB | CategoryTheory.AB4 AddCommGrpCat | true |
ContinuousAt.lineMap | Mathlib.Topology.Algebra.Affine | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_3} [inst : AddCommGroup V] [inst_1 : TopologicalSpace V]
[inst_2 : AddTorsor V P] [inst_3 : TopologicalSpace P] [IsTopologicalAddTorsor P] [inst_5 : Ring R]
[inst_6 : Module R V] [inst_7 : TopologicalSpace R] [ContinuousSMul R V] {X : Type u_6} [inst_9 : TopologicalSpace X]
{f₁ f₂ : X → P} {g : X → R} {x : X},
ContinuousAt f₁ x →
ContinuousAt f₂ x → ContinuousAt g x → ContinuousAt (fun x => (AffineMap.lineMap (f₁ x) (f₂ x)) (g x)) x | true |
AddMonoidAlgebra.le_infDegree_mul | Mathlib.Algebra.MonoidAlgebra.Degree | ∀ {R : Type u_1} {A : Type u_3} {T : Type u_4} [inst : Semiring R] [inst_1 : SemilatticeInf T] [inst_2 : OrderTop T]
[inst_3 : AddZeroClass A] [inst_4 : Add T] [AddLeftMono T] [AddRightMono T] (D : A →ₙ+ T)
(f g : AddMonoidAlgebra R A),
AddMonoidAlgebra.infDegree (⇑D) f + AddMonoidAlgebra.infDegree (⇑D) g ≤ AddMonoidAlgebra.infDegree (⇑D) (f * g) | true |
Lean.Elab.Term.Quotation.elabQuot._@.Lean.Elab.Quotation.1964439861._hygCtx._hyg.3 | Lean.Elab.Quotation | Lean.Elab.Term.TermElab | false |
_private.Mathlib.RingTheory.Polynomial.UniversalFactorizationRing.0.Polynomial.instFiniteUniversalFactorizationRing._proof_1 | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ {R : Type u_1} [inst : CommRing R] {n : ℕ} (m k : ℕ) (hn : n = m + k) (p : Polynomial.MonicDegreeEq R n),
Module.Finite R (Polynomial.UniversalFactorizationRing m k hn p) | false |
_private.Mathlib.Data.Int.Interval.0.Int.instLocallyFiniteOrder._proof_5 | Mathlib.Data.Int.Interval | ∀ (a b x : ℤ), a ≤ x ∧ x ≤ b → ¬((x - a).toNat < (b + 1 - a).toNat ∧ a + ↑(x - a).toNat = x) → False | false |
instCompleteLatticeStructureGroupoid._proof_7 | Mathlib.Geometry.Manifold.StructureGroupoid | ∀ {H : Type u_1} [inst : TopologicalSpace H] (a b : StructureGroupoid H), b ≤ SemilatticeSup.sup a b | false |
_private.Mathlib.RingTheory.Nilpotent.Exp.0.IsNilpotent.exp_add_of_commute._proof_1_3 | Mathlib.RingTheory.Nilpotent.Exp | ∀ (n₁ n₂ : ℕ), max n₁ n₂ + 1 + (max n₁ n₂ + 1) ≤ 2 * max n₁ n₂ + 1 + 1 | false |
_private.Lean.Meta.Tactic.ExposeNames.0.Lean.Meta.getLCtxWithExposedNames | Lean.Meta.Tactic.ExposeNames | Lean.MetaM Lean.LocalContext | true |
List.cons.inj | Init.Core | ∀ {α : Type u} {head : α} {tail : List α} {head_1 : α} {tail_1 : List α},
head :: tail = head_1 :: tail_1 → head = head_1 ∧ tail = tail_1 | true |
Empty.borelSpace | Mathlib.MeasureTheory.Constructions.BorelSpace.Basic | BorelSpace Empty | true |
QuaternionAlgebra.Basis.k_compHom | Mathlib.Algebra.QuaternionBasis | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Ring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] {c₁ c₂ c₃ : R} (q : QuaternionAlgebra.Basis A c₁ c₂ c₃) (F : A →ₐ[R] B),
(q.compHom F).k = F q.k | true |
Std.Tactic.BVDecide.BVExpr.bitblast.goCache._mutual._proof_53 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | ∀ (aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) (w w_1 n : ℕ) (h : w = w_1 * n)
(aig_1 : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) (expr : aig_1.RefVec w_1)
(haig : aig.decls.size ≤ { aig := aig_1, vec := expr }.aig.decls.size),
(↑⟨{ aig := aig_1, vec := expr }, haig⟩).aig.decls.size ≤
(Std.Tactic.BVDecide.BVExpr.bitblast.blastReplicate (↑⟨{ aig := aig_1, vec := expr }, haig⟩).aig
{ w := w_1, n := n, inner := expr, h := h }).aig.decls.size | false |
Std.Time.Month.Ordinal.january | Std.Time.Date.Unit.Month | Std.Time.Month.Ordinal | true |
Aesop.RuleResult.ctorIdx | Aesop.Search.Expansion | Aesop.RuleResult → ℕ | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastAdd._proof_4 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add | ∀ {w : ℕ}, ∀ curr < w, curr + 1 ≤ w | false |
CategoryTheory.ShortComplex.LeftHomologyData.ofEpiOfIsIsoOfMono'._proof_4 | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) (h : S₂.LeftHomologyData) [CategoryTheory.Epi φ.τ₁]
[inst_3 : CategoryTheory.IsIso φ.τ₂]
(wi : CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp h.i (CategoryTheory.inv φ.τ₂)) S₁.g = 0)
(hi :
CategoryTheory.Limits.IsLimit
(CategoryTheory.Limits.KernelFork.ofι (CategoryTheory.CategoryStruct.comp h.i (CategoryTheory.inv φ.τ₂)) wi)),
hi.lift (CategoryTheory.Limits.KernelFork.ofι S₁.f ⋯) = CategoryTheory.CategoryStruct.comp φ.τ₁ h.f' →
∀ {Z' : C} (x : h.K ⟶ Z'),
CategoryTheory.CategoryStruct.comp (hi.lift (CategoryTheory.Limits.KernelFork.ofι S₁.f ⋯)) x = 0 →
CategoryTheory.CategoryStruct.comp h.f' x = 0 | false |
Subsemiring.instTop._proof_2 | Mathlib.Algebra.Ring.Subsemiring.Defs | ∀ {R : Type u_1} [inst : NonAssocSemiring R], 0 ∈ ⊤.carrier | false |
_private.Mathlib.Algebra.Module.Submodule.Lattice.0.Submodule.mem_finsetInf._simp_1_2 | Mathlib.Algebra.Module.Submodule.Lattice | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋂ i, s i) = ∀ (i : ι), x ∈ s i | false |
RootPairing.Hom.comp._proof_3 | Mathlib.LinearAlgebra.RootSystem.Hom | ∀ {ι : Type u_6} {R : Type u_4} {M : Type u_7} {N : Type u_1} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {ι₁ : Type u_8} {M₁ : Type u_9} {N₁ : Type u_5}
{ι₂ : Type u_2} {M₂ : Type u_10} {N₂ : Type u_3} [inst_5 : AddCommGroup M₁] [inst_6 : Module R M₁]
[inst_7 : AddCommGroup N₁] [inst_8 : Module R N₁] [inst_9 : AddCommGroup M₂] [inst_10 : Module R M₂]
[inst_11 : AddCommGroup N₂] [inst_12 : Module R N₂] {P : RootPairing ι R M N} {P₁ : RootPairing ι₁ R M₁ N₁}
{P₂ : RootPairing ι₂ R M₂ N₂} (g : P₁.Hom P₂) (f : P.Hom P₁),
⇑(f.coweightMap ∘ₗ g.coweightMap) ∘ ⇑P₂.coroot = ⇑P.coroot ∘ ⇑(f.indexEquiv.trans g.indexEquiv).symm | false |
SchwartzMap.compCLM._proof_3 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ (k n l : ℕ) (C : ℝ),
0 ≤ C →
∀ (kg : ℕ) (Cg : ℝ), 1 ≤ 1 + Cg → 0 ≤ (1 + Cg) ^ (k + l * n) * ((C + 1) ^ n * ↑n.factorial * 2 ^ (kg * (k + l * n))) | false |
CategoryTheory.MorphismProperty.precoverage_monotone | Mathlib.CategoryTheory.Sites.MorphismProperty | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P Q : CategoryTheory.MorphismProperty C},
P ≤ Q → P.precoverage ≤ Q.precoverage | true |
RingHom.formallyEtale_algebraMap | Mathlib.RingTheory.Etale.Basic | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
(algebraMap R S).FormallyEtale ↔ Algebra.FormallyEtale R S | true |
Order.Ideal.coe_sup_eq | Mathlib.Order.Ideal | ∀ {P : Type u_1} [inst : DistribLattice P] {I J : Order.Ideal P}, ↑(I ⊔ J) = {x | ∃ i ∈ I, ∃ j ∈ J, x = i ⊔ j} | true |
ContinuousMultilinearMap.smulRight_apply | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {R : Type u} {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} [inst : CommSemiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
[inst_4 : Module R M₂] [inst_5 : TopologicalSpace R] [inst_6 : (i : ι) → TopologicalSpace (M₁ i)]
[inst_7 : TopologicalSpace M₂] [inst_8 : ContinuousSMul R M₂] (f : ContinuousMultilinearMap R M₁ R) (z : M₂)
(a : (i : ι) → M₁ i), (f.smulRight z) a = f a • z | true |
Int.negOnePow_two_mul_add_one | Mathlib.Algebra.Ring.NegOnePow | ∀ (n : ℤ), (2 * n + 1).negOnePow = -1 | true |
Lean.Server.Watchdog.CallHierarchyItemData | Lean.Server.Watchdog | Type | true |
Std.Time.FormatPart.noConfusionType | Std.Time.Format.Basic | Sort u → Std.Time.FormatPart → Std.Time.FormatPart → Sort u | false |
Nat.testBit_ofBits_lt | Batteries.Data.Nat.Lemmas | ∀ {n : ℕ} (f : Fin n → Bool) (i : ℕ) (h : i < n), (Nat.ofBits f).testBit i = f ⟨i, h⟩ | true |
HahnSeries.leadingCoeff_abs | Mathlib.RingTheory.HahnSeries.Lex | ∀ {Γ : Type u_1} {R : Type u_2} [inst : LinearOrder Γ] [inst_1 : LinearOrder R] [inst_2 : AddCommGroup R]
[IsOrderedAddMonoid R] (x : Lex (HahnSeries Γ R)), (ofLex |x|).leadingCoeff = |(ofLex x).leadingCoeff| | true |
isOpenMap_sigmaMk | Mathlib.Topology.Constructions | ∀ {ι : Type u_5} {σ : ι → Type u_7} [inst : (i : ι) → TopologicalSpace (σ i)] {i : ι}, IsOpenMap (Sigma.mk i) | true |
SimpleGraph.TripartiteFromTriangles.NoAccidental.mk._flat_ctor | Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {t : Finset (α × β × γ)},
(∀ ⦃a a' : α⦄ ⦃b b' : β⦄ ⦃c c' : γ⦄, (a', b, c) ∈ t → (a, b', c) ∈ t → (a, b, c') ∈ t → a = a' ∨ b = b' ∨ c = c') →
SimpleGraph.TripartiteFromTriangles.NoAccidental t | false |
Int64.right_eq_add | Init.Data.SInt.Lemmas | ∀ {a b : Int64}, b = a + b ↔ a = 0 | true |
Std.TreeMap.Raw.mem_union_of_left | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → ∀ {k : α}, k ∈ t₁ → k ∈ t₁ ∪ t₂ | true |
MvPowerSeries.one_le_order_iff_constCoeff_eq_zero | Mathlib.RingTheory.MvPowerSeries.Order | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] {f : MvPowerSeries σ R},
1 ≤ f.order ↔ MvPowerSeries.constantCoeff f = 0 | true |
CompletelyDistribLattice.top_sdiff | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u} [self : CompletelyDistribLattice α] (a : α), ⊤ \ a = ￢a | true |
IsInvariantSubring.toMulSemiringAction._proof_1 | Mathlib.Algebra.Ring.Action.Invariant | ∀ (M : Type u_2) {R : Type u_1} [inst : Monoid M] [inst_1 : Ring R] [inst_2 : MulSemiringAction M R] (S : Subring R)
[IsInvariantSubring M S] (m : M) (x : ↥S), m • ↑x ∈ S | false |
Lean.Widget.GetInteractiveDiagnosticsParams.mk.sizeOf_spec | Lean.Server.FileWorker.WidgetRequests | ∀ (lineRange? : Option Lean.Lsp.LineRange), sizeOf { lineRange? := lineRange? } = 1 + sizeOf lineRange? | true |
Std.Net.SocketAddress | Std.Net.Addr | Type | true |
IsClosedMap.specializingMap | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
IsClosedMap f → SpecializingMap f | true |
CategoryTheory.ProjectiveResolution.liftHomotopyZeroSucc_comp_assoc | Mathlib.CategoryTheory.Abelian.Projective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {Y Z : C}
{P : CategoryTheory.ProjectiveResolution Y} {Q : CategoryTheory.ProjectiveResolution Z} (f : P.complex ⟶ Q.complex)
(n : ℕ) (g : P.complex.X n ⟶ Q.complex.X (n + 1)) (g' : P.complex.X (n + 1) ⟶ Q.complex.X (n + 2))
(w :
f.f (n + 1) =
CategoryTheory.CategoryStruct.comp (P.complex.d (n + 1) n) g +
CategoryTheory.CategoryStruct.comp g' (Q.complex.d (n + 2) (n + 1)))
{Z_1 : C} (h : Q.complex.X (n + 2) ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (CategoryTheory.ProjectiveResolution.liftHomotopyZeroSucc f n g g' w)
(CategoryTheory.CategoryStruct.comp (Q.complex.d (n + 3) (n + 2)) h) =
CategoryTheory.CategoryStruct.comp
(f.f (n + 2) - CategoryTheory.CategoryStruct.comp (P.complex.d (n + 2) (n + 1)) g') h | true |
CategoryTheory.Functor.IsEventuallyConstantFrom.isIso_ι_of_isColimit' | Mathlib.CategoryTheory.Limits.Constructions.EventuallyConstant | ∀ {J : Type u_1} {C : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] {F : CategoryTheory.Functor J C} {i₀ : J},
F.IsEventuallyConstantFrom i₀ →
∀ [CategoryTheory.IsFiltered J] {c : CategoryTheory.Limits.Cocone F} (hc : CategoryTheory.Limits.IsColimit c)
(j : J) (ι : i₀ ⟶ j), CategoryTheory.IsIso (c.ι.app j) | true |
_private.Lean.Syntax.0.Lean.Syntax.findStack?.go.match_3 | Lean.Syntax | (motive : Option (Option Lean.Syntax.Stack) → Sort u_1) →
(x : Option (Option Lean.Syntax.Stack)) →
(Unit → motive none) → ((a : Option Lean.Syntax.Stack) → motive (some a)) → motive x | false |
PUnit.inv_eq | Mathlib.Algebra.Group.PUnit | ∀ (x : PUnit.{u_1 + 1}), x⁻¹ = PUnit.unit | true |
CategoryTheory.Functor.mapCocone₂_pt | Mathlib.CategoryTheory.Limits.Preserves.Bifunctor | ∀ {J₁ : Type u_1} {J₂ : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} J₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} J₂] {C₁ : Type u_3} {C₂ : Type u_4} {C : Type u_5}
[inst_2 : CategoryTheory.Category.{v_3, u_3} C₁] [inst_3 : CategoryTheory.Category.{v_4, u_4} C₂]
[inst_4 : CategoryTheory.Category.{v_5, u_5} C] (G : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C))
{K₁ : CategoryTheory.Functor J₁ C₁} {K₂ : CategoryTheory.Functor J₂ C₂} (c₁ : CategoryTheory.Limits.Cocone K₁)
(c₂ : CategoryTheory.Limits.Cocone K₂), (G.mapCocone₂ c₁ c₂).pt = (G.obj c₁.pt).obj c₂.pt | true |
CauSeq.equiv_lim | Mathlib.Algebra.Order.CauSeq.Completion | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] {β : Type u_2}
[inst_3 : Ring β] {abv : β → α} [inst_4 : IsAbsoluteValue abv] [inst_5 : CauSeq.IsComplete β abv] (s : CauSeq β abv),
s ≈ CauSeq.const abv s.lim | true |
MontelSpace.rec | Mathlib.Analysis.LocallyConvex.Montel | {𝕜 : Type u_4} →
{E : Type u_5} →
[inst : SeminormedRing 𝕜] →
[inst_1 : Zero E] →
[inst_2 : SMul 𝕜 E] →
[inst_3 : TopologicalSpace E] →
{motive : MontelSpace 𝕜 E → Sort u} →
((heine_borel : ∀ (s : Set E), IsClosed s → Bornology.IsVonNBounded 𝕜 s → IsCompact s) → motive ⋯) →
(t : MontelSpace 𝕜 E) → motive t | false |
Subgroup.pi | Mathlib.Algebra.Group.Subgroup.Basic | {η : Type u_7} →
{f : η → Type u_8} → [inst : (i : η) → Group (f i)] → Set η → ((i : η) → Subgroup (f i)) → Subgroup ((i : η) → f i) | true |
Set.zero_notMem_sub_iff | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : AddGroup α] {s t : Set α}, 0 ∉ s - t ↔ Disjoint s t | true |
_private.Lean.Elab.App.0.Lean.Elab.Term.ElabAppArgs.processImplicitArg | Lean.Elab.App | Lean.Name → Lean.Elab.Term.ElabAppArgs.M Lean.Expr | true |
List.Subset.antisymm_of_sortedLT | Mathlib.Data.List.Sort | ∀ {α : Type u_1} [inst : PartialOrder α] {l₁ l₂ : List α}, l₁ ⊆ l₂ → l₂ ⊆ l₁ → l₁.SortedLT → l₂.SortedLT → l₁ = l₂ | true |
Aesop.GoalWithMVars.recOn | Aesop.Script.GoalWithMVars | {motive : Aesop.GoalWithMVars → Sort u} →
(t : Aesop.GoalWithMVars) →
((goal : Lean.MVarId) → (mvars : Std.HashSet Lean.MVarId) → motive { goal := goal, mvars := mvars }) → motive t | false |
Std.ExtDTreeMap.getKey?_maxKey | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
{he : t ≠ ∅}, t.getKey? (t.maxKey he) = some (t.maxKey he) | true |
Concept.extent_sup | Mathlib.Order.Concept | ∀ {α : Type u_2} {β : Type u_3} {r : α → β → Prop} (c d : Concept α β r),
(c ⊔ d).extent = lowerPolar r (c.intent ∩ d.intent) | true |
SimpleGraph.Subgraph._sizeOf_1 | Mathlib.Combinatorics.SimpleGraph.Subgraph | {V : Type u} → {G : SimpleGraph V} → [SizeOf V] → G.Subgraph → ℕ | false |
Function.Surjective.addAction._proof_1 | Mathlib.Algebra.Group.Action.Defs | ∀ {M : Type u_2} {α : Type u_3} {β : Type u_1} [inst : AddMonoid M] [inst_1 : AddAction M α] [inst_2 : VAdd M β]
(f : α → β),
Function.Surjective f → (∀ (c : M) (x : α), f (c +ᵥ x) = c +ᵥ f x) → ∀ (x y : M) (b : β), (x + y) +ᵥ b = x +ᵥ y +ᵥ b | false |
_private.Lean.Compiler.IR.EmitLLVM.0.Lean.IR.EmitLLVM.emitDeclAux.match_1 | Lean.Compiler.IR.EmitLLVM | (motive : Lean.IR.Decl → Sort u_1) →
(d : Lean.IR.Decl) →
((f : Lean.IR.FunId) →
(xs : Array Lean.IR.Param) →
(t : Lean.IR.IRType) →
(b : Lean.IR.FnBody) → (info : Lean.IR.DeclInfo) → motive (Lean.IR.Decl.fdecl f xs t b info)) →
((x : Lean.IR.Decl) → motive x) → motive d | false |
Matrix.center_eq_range | Mathlib.Data.Matrix.Basis | ∀ {n : Type u_3} (R : Type u_5) [inst : DecidableEq n] [inst_1 : Fintype n] [inst_2 : CommSemiring R],
Set.center (Matrix n n R) = Set.range ⇑(Matrix.scalar n) | true |
AddMonoidHom.range_eq_top_of_surjective | Mathlib.Algebra.Group.Subgroup.Ker | ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_7} [inst_1 : AddGroup N] (f : G →+ N),
Function.Surjective ⇑f → f.range = ⊤ | true |
Real.convergent_zero | Mathlib.NumberTheory.DiophantineApproximation.Basic | ∀ (ξ : ℝ), ξ.convergent 0 = ↑⌊ξ⌋ | true |
CategoryTheory.Bicategory.conjugateIsoEquiv_apply_inv | Mathlib.CategoryTheory.Bicategory.Adjunction.Mate | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {c d : B} {l₁ l₂ : c ⟶ d} {r₁ r₂ : d ⟶ c}
(adj₁ : CategoryTheory.Bicategory.Adjunction l₁ r₁) (adj₂ : CategoryTheory.Bicategory.Adjunction l₂ r₂) (α : l₂ ≅ l₁),
((CategoryTheory.Bicategory.conjugateIsoEquiv adj₁ adj₂) α).inv =
(CategoryTheory.Bicategory.conjugateEquiv adj₂ adj₁) α.inv | true |
mapsTo_gaugeRescale_closure | Mathlib.Analysis.Convex.GaugeRescale | ∀ {E : Type u_1} [inst : AddCommGroup E] [inst_1 : Module ℝ E] [inst_2 : TopologicalSpace E] [IsTopologicalAddGroup E]
[ContinuousSMul ℝ E] {s t : Set E},
Convex ℝ s → s ∈ nhds 0 → Convex ℝ t → 0 ∈ t → Absorbent ℝ t → Set.MapsTo (gaugeRescale s t) (closure s) (closure t) | true |
Std.HashMap.mem_alter_of_beq | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{k k' : α} {f : Option β → Option β}, (k == k') = true → (k' ∈ m.alter k f ↔ (f m[k]?).isSome = true) | true |
Monotone.forall | Mathlib.Order.BoundedOrder.Monotone | ∀ {α : Type u} {β : Type v} [inst : Preorder α] {P : β → α → Prop},
(∀ (x : β), Monotone (P x)) → Monotone fun y => ∀ (x : β), P x y | true |
Std.Time.Duration.mk._flat_ctor | Std.Time.Duration | (second : Std.Time.Second.Offset) →
(nano : Std.Time.Nanosecond.Span) → second.val ≥ 0 ∧ ↑nano ≥ 0 ∨ second.val ≤ 0 ∧ ↑nano ≤ 0 → Std.Time.Duration | false |
FBinopElab.instInhabitedSRec | Mathlib.Tactic.FBinop | Inhabited FBinopElab.SRec | true |
CategoryTheory.Meq.congr_apply | Mathlib.CategoryTheory.Sites.ConcreteSheafification | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {D : Type w}
[inst_1 : CategoryTheory.Category.{w', w} D] {FD : D → D → Type u_1} {CD : D → Type t}
[inst_2 : (X Y : D) → FunLike (FD X Y) (CD X) (CD Y)] [inst_3 : CategoryTheory.ConcreteCategory D FD] {X : C}
{P : CategoryTheory.Functor Cᵒᵖ D} {S : J.Cover X} (x : CategoryTheory.Meq P S) {Y : C} {f g : Y ⟶ X} (h : f = g)
(hf : (↑S).arrows f), ↑x { Y := Y, f := f, hf := hf } = ↑x { Y := Y, f := g, hf := ⋯ } | true |
_private.Lean.Compiler.IR.SimpleGroundExpr.0.Lean.IR.SimpleGroundValue.uint8.sizeOf_spec | Lean.Compiler.IR.SimpleGroundExpr | ∀ (val : UInt8), sizeOf (Lean.IR.SimpleGroundValue.uint8✝ val) = 1 + sizeOf val | true |
CategoryTheory.Limits.FormalCoproduct.cechFunctor | Mathlib.CategoryTheory.Limits.FormalCoproducts.Cech | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.Limits.HasFiniteProducts C] →
CategoryTheory.Functor (CategoryTheory.Limits.FormalCoproduct C)
(CategoryTheory.SimplicialObject (CategoryTheory.Limits.FormalCoproduct C)) | true |
Mathlib.Tactic.Conv.Path.brecOn | Mathlib.Tactic.Widget.Conv | {motive : Mathlib.Tactic.Conv.Path → Sort u} →
(t : Mathlib.Tactic.Conv.Path) →
((t : Mathlib.Tactic.Conv.Path) → Mathlib.Tactic.Conv.Path.below t → motive t) → motive t | false |
Std.ExtDHashMap.get_union_of_not_mem_left | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m₁ m₂ : Std.ExtDHashMap α β} [inst : LawfulBEq α]
{k : α} (not_mem : k ∉ m₁) {h' : k ∈ m₁ ∪ m₂}, (m₁ ∪ m₂).get k h' = m₂.get k ⋯ | true |
Lean.Meta.Grind.Arith.Linear.DiseqCnstrProof.core | Lean.Meta.Tactic.Grind.Arith.Linear.Types | Lean.Expr →
Lean.Expr →
Lean.Meta.Grind.Arith.Linear.LinExpr →
Lean.Meta.Grind.Arith.Linear.LinExpr → Lean.Meta.Grind.Arith.Linear.DiseqCnstrProof | true |
CategoryTheory.Bicategory.Adjunction.mk.injEq | Mathlib.CategoryTheory.Bicategory.Adjunction.Basic | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b : B} {f : a ⟶ b} {g : b ⟶ a}
(unit : CategoryTheory.CategoryStruct.id a ⟶ CategoryTheory.CategoryStruct.comp f g)
(counit : CategoryTheory.CategoryStruct.comp g f ⟶ CategoryTheory.CategoryStruct.id b)
(left_triangle :
autoParam
(CategoryTheory.Bicategory.leftZigzag unit counit =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.leftUnitor f).hom
(CategoryTheory.Bicategory.rightUnitor f).inv)
CategoryTheory.Bicategory.Adjunction.left_triangle._autoParam)
(right_triangle :
autoParam
(CategoryTheory.Bicategory.rightZigzag unit counit =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.rightUnitor g).hom
(CategoryTheory.Bicategory.leftUnitor g).inv)
CategoryTheory.Bicategory.Adjunction.right_triangle._autoParam)
(unit_1 : CategoryTheory.CategoryStruct.id a ⟶ CategoryTheory.CategoryStruct.comp f g)
(counit_1 : CategoryTheory.CategoryStruct.comp g f ⟶ CategoryTheory.CategoryStruct.id b)
(left_triangle_1 :
autoParam
(CategoryTheory.Bicategory.leftZigzag unit_1 counit_1 =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.leftUnitor f).hom
(CategoryTheory.Bicategory.rightUnitor f).inv)
CategoryTheory.Bicategory.Adjunction.left_triangle._autoParam)
(right_triangle_1 :
autoParam
(CategoryTheory.Bicategory.rightZigzag unit_1 counit_1 =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.rightUnitor g).hom
(CategoryTheory.Bicategory.leftUnitor g).inv)
CategoryTheory.Bicategory.Adjunction.right_triangle._autoParam),
({ unit := unit, counit := counit, left_triangle := left_triangle, right_triangle := right_triangle } =
{ unit := unit_1, counit := counit_1, left_triangle := left_triangle_1, right_triangle := right_triangle_1 }) =
(unit = unit_1 ∧ counit = counit_1) | true |
Mathlib.Tactic.ITauto.Proof.em | Mathlib.Tactic.ITauto | Bool → Lean.Name → Mathlib.Tactic.ITauto.Proof | true |
Finset.isPWO_sup | Mathlib.Order.WellFoundedSet | ∀ {ι : Type u_1} {α : Type u_2} [inst : Preorder α] (s : Finset ι) {f : ι → Set α},
(s.sup f).IsPWO ↔ ∀ i ∈ s, (f i).IsPWO | true |
Lean.NameMapExtension.find? | Batteries.Lean.NameMapAttribute | {α : Type} → Lean.NameMapExtension α → Lean.Environment → Lean.Name → Option α | true |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr.0.Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.natAbs.sizeOf_spec | Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr | sizeOf Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.natAbs✝ = 1 | true |
Std.Iter.foldM_filterM | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {α β δ : Type w} {n : Type w → Type w''} {o : Type w → Type w'''} [inst : Std.Iterator α Id β]
[Std.Iterators.Finite α Id] [inst_2 : Monad n] [inst_3 : MonadAttach n] [LawfulMonad n] [WeaklyLawfulMonadAttach n]
[inst_6 : Monad o] [LawfulMonad o] [inst_8 : Std.IteratorLoop α Id n] [inst_9 : Std.IteratorLoop α Id o]
[Std.LawfulIteratorLoop α Id n] [Std.LawfulIteratorLoop α Id o] [inst_12 : MonadLiftT n o] [LawfulMonadLiftT n o]
{f : β → n (ULift.{w, 0} Bool)} {g : δ → β → o δ} {init : δ} {it : Std.Iter β},
Std.IterM.foldM g init (Std.Iter.filterM f it) =
Std.Iter.foldM
(fun d b => do
let __do_lift ← liftM (f b)
if __do_lift.down = true then g d b else pure d)
init it | true |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.prefixFunctionRecurrence._unary._proof_5 | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ (pat : ByteArray) (stackPos : ℕ) (hst : stackPos < pat.size) (guess : ℕ) (hg : guess < stackPos)
(this : String.Slice.Pattern.Model.ForwardSliceSearcher.prefixFunction✝ pat (guess - 1) ⋯ < guess),
String.Slice.Pattern.Model.ForwardSliceSearcher.prefixFunction✝¹ pat (guess - 1) ⋯ < stackPos | false |
CategoryTheory.ComonObj.comul | Mathlib.CategoryTheory.Monoidal.Comon_ | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{inst_1 : CategoryTheory.MonoidalCategory C} →
{X : C} → [self : CategoryTheory.ComonObj X] → X ⟶ CategoryTheory.MonoidalCategoryStruct.tensorObj X X | true |
PointedCone.mem_closure | Mathlib.Analysis.Convex.Cone.Closure | ∀ {𝕜 : Type u_1} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : IsOrderedRing 𝕜] {E : Type u_2}
[inst_3 : AddCommMonoid E] [inst_4 : TopologicalSpace E] [inst_5 : ContinuousAdd E] [inst_6 : Module 𝕜 E]
[inst_7 : ContinuousConstSMul 𝕜 E] {K : PointedCone 𝕜 E} {a : E}, a ∈ K.closure ↔ a ∈ closure ↑K | true |
Continuous.fourier_inversion | Mathlib.Analysis.Fourier.Inversion | ∀ {V : Type u_1} {E : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
[inst_2 : MeasurableSpace V] [inst_3 : BorelSpace V] [inst_4 : FiniteDimensional ℝ V] [inst_5 : NormedAddCommGroup E]
[inst_6 : NormedSpace ℂ E] {f : V → E} [CompleteSpace E],
Continuous f →
MeasureTheory.Integrable f MeasureTheory.volume →
MeasureTheory.Integrable (FourierTransform.fourier f) MeasureTheory.volume →
FourierTransformInv.fourierInv (FourierTransform.fourier f) = f | true |
SeparationQuotient.instRing._proof_12 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : Ring R] [inst_2 : IsTopologicalRing R] (x : R),
SeparationQuotient.mk (-x) = -SeparationQuotient.mk x | false |
Prod.instBornology._proof_1 | Mathlib.Topology.Bornology.Constructions | ∀ {α : Type u_1} {β : Type u_2} [inst : Bornology α] [inst_1 : Bornology β],
(Bornology.cobounded α).coprod (Bornology.cobounded β) ≤ Filter.cofinite | false |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Removal.0.Mathlib.Meta.Positivity.evalTriangleRemovalBound.match_4 | Mathlib.Combinatorics.SimpleGraph.Triangle.Removal | (α : Q(Type)) →
(_zα : Q(Zero «$α»)) →
(_pα : Q(PartialOrder «$α»)) →
(ε : Q(ℝ)) →
(motive : Mathlib.Meta.Positivity.Strictness q(inferInstance) q(inferInstance) ε → Sort u_1) →
(__discr : Mathlib.Meta.Positivity.Strictness q(inferInstance) q(inferInstance) ε) →
((hε : Q(0 < «$ε»)) → motive (Mathlib.Meta.Positivity.Strictness.positive hε)) →
((x : Mathlib.Meta.Positivity.Strictness q(inferInstance) q(inferInstance) ε) → motive x) → motive __discr | false |
Lean.Compiler.LCNF.instTraverseFVarArg | Lean.Compiler.LCNF.FVarUtil | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.TraverseFVar (Lean.Compiler.LCNF.Arg pu) | true |
Nat.mem_divisors_self | Mathlib.NumberTheory.Divisors | ∀ (n : ℕ), n ≠ 0 → n ∈ n.divisors | true |
CochainComplex.mappingCone.δ_descCochain._proof_2 | Mathlib.Algebra.Homology.HomotopyCategory.MappingCone | ∀ {n : ℤ} (n' : ℤ), n + 1 = n' → 1 + n = n' | false |
AlgebraicGeometry.Scheme.Cover.Over | Mathlib.AlgebraicGeometry.Cover.Over | (S : AlgebraicGeometry.Scheme) →
{P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} →
[P.IsStableUnderBaseChange] →
[AlgebraicGeometry.Scheme.IsJointlySurjectivePreserving P] →
{X : AlgebraicGeometry.Scheme} →
[X.Over S] → AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) X → Type (max u u_1) | true |
ValuativeRel.ValueGroupWithZero.exact | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : ValuativeRel R] {x y : R} {t s : ↥(ValuativeRel.posSubmonoid R)},
ValuativeRel.ValueGroupWithZero.mk x t = ValuativeRel.ValueGroupWithZero.mk y s → x * ↑s ≤ᵥ y * ↑t ∧ y * ↑t ≤ᵥ x * ↑s | true |
Ordering.swap.eq_3 | Std.Data.DTreeMap.Internal.Model | Ordering.gt.swap = Ordering.lt | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.