name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
PresheafOfModules.Sheafify.SMulCandidate.mk'._proof_1 | Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafify | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {J : CategoryTheory.GrothendieckTopology C}
{R₀ : CategoryTheory.Functor Cᵒᵖ RingCat} {R : CategoryTheory.Sheaf J RingCat} (α : R₀ ⟶ R.obj)
[CategoryTheory.Presheaf.IsLocallyInjective J α] {M₀ : PresheafOfModules R₀}
{A : CategoryTheory.Sheaf J AddCom... | false |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic.0.IntervalIntegrable.comp_mul_left._simp_1_6 | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | false |
Stream'.Seq.ofList._proof_1 | Mathlib.Data.Seq.Defs | ∀ {α : Type u_1} (l : List α) {n : ℕ}, (fun x => l[x]?) n = none → (fun x => l[x]?) (n + 1) = none | false |
AddCommGrpCat.limitCone._proof_1 | Mathlib.Algebra.Category.Grp.Limits | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_3, u_2} J] (F : CategoryTheory.Functor J AddCommGrpCat)
[Small.{u_1, max u_1 u_2} ↑(F.comp (CategoryTheory.forget AddCommGrpCat)).sections],
Small.{u_1, max u_1 u_2}
↑((F.comp (CategoryTheory.forget₂ AddCommGrpCat AddGrpCat)).comp (CategoryTheory.forget AddGrp... | false |
borel_anti | Mathlib.MeasureTheory.Constructions.BorelSpace.Basic | ∀ {α : Type u_1}, Antitone (@borel α) | true |
Std.DTreeMap.Internal.Impl.maxEntry.match_1 | Std.Data.DTreeMap.Internal.Queries | {α : Type u_1} →
{β : α → Type u_2} →
(motive : (x : Std.DTreeMap.Internal.Impl α β) → x.isEmpty = false → Sort u_3) →
(x : Std.DTreeMap.Internal.Impl α β) →
(x_1 : x.isEmpty = false) →
((size : ℕ) →
(k : α) →
(v : β k) →
(l : Std.DTreeMap.In... | false |
Std.TreeMap.instSliceableRioSlice | Std.Data.TreeMap.Slice | {α : Type u} →
{β : Type v} →
(cmp : autoParam (α → α → Ordering) Std.TreeMap.instSliceableRioSlice._auto_1) →
Std.Rio.Sliceable (Std.TreeMap α β cmp) α (Std.DTreeMap.Internal.Const.RioSlice α β) | true |
HurwitzZeta.sinKernel.eq_1 | Mathlib.NumberTheory.LSeries.HurwitzZetaOdd | ∀ (a : UnitAddCircle) (x : ℝ), HurwitzZeta.sinKernel a x = ⋯.lift a | true |
_private.Mathlib.Combinatorics.SimpleGraph.Metric.0.SimpleGraph.Walk.exists_adj_adj_not_adj_ne._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Metric | ∀ {V : Type u} {G : SimpleGraph V} {v w : V} {p : G.Walk v w}, p.Nil = (p.length = 0) | false |
UInt64.instLawfulOrderOrd | Init.Data.Ord.UInt | Std.LawfulOrderOrd UInt64 | true |
CategoryTheory.WithInitial.mkCommaObject_right_map | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
(F : CategoryTheory.Functor (CategoryTheory.WithInitial C) D) {X Y : C} (f : X ⟶ Y),
(CategoryTheory.WithInitial.mkCommaObject F).right.map f = F.map (CategoryTheory.WithInitial.incl.map f) | true |
CategoryTheory.Pseudofunctor.DescentData.pullFunctor_obj | Mathlib.CategoryTheory.Sites.Descent.DescentData | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
(F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat) {ι : Type t} {S : C}
{X : ι → C} {f : (i : ι) → X i ⟶ S} {S' : C} {p : S' ⟶ S} {ι' : Type t'} {X' : ι' → C} {f' : (j : ι') → X' j ⟶ S'}
{α : ι' → ι} {p' : (j : ι') → ... | true |
SimpleGraph.Subgraph.topIso._proof_3 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} (x : ↑⊤.verts), ⟨↑x, ⋯⟩ = x | false |
BotHom.instDistribLattice._proof_4 | Mathlib.Order.Hom.Bounded | ∀ {α : Type u_1} {β : Type u_2} [inst : Bot α] [inst_1 : DistribLattice β] [inst_2 : OrderBot β] (x x_1 : BotHom α β),
⇑(x ⊓ x_1) = ⇑(x ⊓ x_1) | false |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.toOption.eq_3 | Init.Data.String.Pattern.String | ∀ {s : String.Slice} (needle : String.Slice) (table : Vector ℕ needle.utf8ByteSize)
(ht : table = String.Slice.Pattern.ForwardSliceSearcher.buildTable needle) (stackPos needlePos : String.Pos.Raw)
(hn : needlePos < needle.rawEndPos),
String.Slice.Pattern.ForwardSliceSearcher.toOption✝
(String.Slice.Pattern.... | true |
_private.Batteries.Data.Nat.Bitwise.0.Nat.and_or_right_injective._simp_1_1 | Batteries.Data.Nat.Bitwise | ∀ (x y i : ℕ), (x.testBit i && y.testBit i) = (x &&& y).testBit i | false |
ProbabilityTheory.variance_sub_const | Mathlib.Probability.Moments.Variance | ∀ {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {X : Ω → ℝ} {μ : MeasureTheory.Measure Ω}
[MeasureTheory.IsProbabilityMeasure μ],
MeasureTheory.AEStronglyMeasurable X μ →
∀ (c : ℝ), ProbabilityTheory.variance (fun ω => X ω - c) μ = ProbabilityTheory.variance X μ | true |
_private.Lean.Compiler.LCNF.AuxDeclCache.0.Lean.Compiler.LCNF.instBEqAuxDeclCacheKey.beq._proof_2 | Lean.Compiler.LCNF.AuxDeclCache | ∀ (a b : Lean.Compiler.LCNF.Purity) (h : (a == b) = true), ⋯ ≍ ⋯ | false |
_private.Init.Data.Option.Instances.0.Option.eq_none_of_isNone.match_1_1 | Init.Data.Option.Instances | ∀ {α : Type u_1} (motive : (x : Option α) → x.isNone = true → Prop) (x : Option α) (x_1 : x.isNone = true),
(∀ (x : none.isNone = true), motive none x) → motive x x_1 | false |
Order.IsIdeal.Directed | Mathlib.Order.Ideal | ∀ {P : Type u_2} [inst : LE P] {I : Set P}, Order.IsIdeal I → DirectedOn (fun x1 x2 => x1 ≤ x2) I | true |
CategoryTheory.Pretriangulated.productTriangle.π_hom₃ | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.HasShift C ℤ] {J : Type u_1}
(T : J → CategoryTheory.Pretriangulated.Triangle C) [inst_2 : CategoryTheory.Limits.HasProduct fun j => (T j).obj₁]
[inst_3 : CategoryTheory.Limits.HasProduct fun j => (T j).obj₂]
[inst_4 : CategoryTheor... | true |
SimpleGraph.Subgraph.instFinite | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} [Finite V], Finite G.Subgraph | true |
CategoryTheory.Limits.Pi.map_π | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {β : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {f g : β → C}
[inst_1 : CategoryTheory.Limits.HasProduct f] [inst_2 : CategoryTheory.Limits.HasProduct g] (p : (b : β) → f b ⟶ g b)
(b : β),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Pi.map p) (CategoryTheory.Limits.Pi.π g b) =
... | true |
MeasureTheory.AEEqFun.mul_toGerm | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {α : Type u_1} {γ : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace γ]
[inst_2 : Mul γ] [inst_3 : ContinuousMul γ] (f g : α →ₘ[μ] γ), (f * g).toGerm = f.toGerm * g.toGerm | true |
MvPolynomial.coeff_linearCombination_X_pow | Mathlib.Algebra.MvPolynomial.Coeff | ∀ {R : Type u_1} {σ : Type u_2} [inst : CommSemiring R] (a : σ →₀ R) (s : σ →₀ ℕ) (n : ℕ),
MvPolynomial.coeff s ((Finsupp.linearCombination R MvPolynomial.X) a ^ n) =
if (s.sum fun x m => m) = n then ↑s.multinomial * s.prod fun r m => a r ^ m else 0 | true |
_private.Mathlib.Lean.Meta.CongrTheorems.0.Lean.Meta.mkHCongrWithArity'.prove._sparseCasesOn_3 | Mathlib.Lean.Meta.CongrTheorems | {α : Type u} →
{motive : List α → Sort u_1} →
(t : List α) →
((head : α) → (tail : List α) → motive (head :: tail)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
UpperSet.Ici_ne_top._simp_2 | Mathlib.Order.UpperLower.Principal | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, (UpperSet.Ici a = ⊤) = False | false |
CategoryTheory.ObjectProperty.fullMonoidalClosedSubcategory._proof_2 | Mathlib.CategoryTheory.Monoidal.Subcategory | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(P : CategoryTheory.ObjectProperty C) [inst_2 : P.IsMonoidal] [inst_3 : CategoryTheory.MonoidalClosed C]
[inst_4 : P.IsMonoidalClosed] (X : P.FullSubcategory) ⦃X_1 Y : P.FullSubcategory⦄ (f : X_1 ⟶ Y),
Cate... | false |
_private.Lean.IdentifierSuggestion.0.Lean.throwUnknownNameWithSuggestions.match_1 | Lean.IdentifierSuggestion | (motive : Option Lean.Name → Sort u_1) →
(x : Option Lean.Name) → (Unit → motive none) → ((prefixName : Lean.Name) → motive (some prefixName)) → motive x | false |
_private.Std.Time.Format.Basic.0.Std.Time.exactlyChars.go._unary._proof_1 | Std.Time.Format.Basic | ∀ (size : ℕ) (acc : String) (count : ℕ),
¬count ≥ size →
∀ (res : Char),
InvImage (fun x1 x2 => x1 < x2) (fun x => PSigma.casesOn x fun acc count => size - count)
⟨acc.push res, count.succ⟩ ⟨acc, count⟩ | false |
Lean.Elab.Tactic.Do.ProofMode.initFn._@.Lean.Elab.Tactic.Do.ProofMode.Cases.723085142._hygCtx._hyg.2 | Lean.Elab.Tactic.Do.ProofMode.Cases | IO Unit | false |
SupHom.subtypeVal | Mathlib.Order.Hom.Lattice | {β : Type u_3} →
[inst : SemilatticeSup β] → {P : β → Prop} → (Psup : ∀ ⦃x y : β⦄, P x → P y → P (x ⊔ y)) → SupHom { x // P x } β | true |
CStarMatrix.of_add_of | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {m : Type u_1} {n : Type u_2} {A : Type u_5} [inst : Add A] (f g : Matrix m n A),
CStarMatrix.ofMatrix f + CStarMatrix.ofMatrix g = CStarMatrix.ofMatrix (f + g) | true |
Lean.Expr.hasLooseBVarInExplicitDomain | Lean.Expr | Lean.Expr → ℕ → Bool → Bool | true |
CategoryTheory.Adjunction.homEquiv_naturality_right_square | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {X' X : C} {Y Y' : D} (f : X' ⟶ X)
(g : X ⟶ G.obj Y') (h : X' ⟶ G.obj Y) (k : Y ⟶ Y'),
CategoryTheory.CategoryStru... | true |
LinearEquiv.coe_injective | Mathlib.Algebra.Module.Equiv.Defs | ∀ {R : Type u_1} {S : Type u_6} {M : Type u_7} {M₂ : Type u_9} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] {modM : Module R M} {modM₂ : Module S M₂} {σ : R →+* S}
{σ' : S →+* R} [inst_4 : RingHomInvPair σ σ'] [inst_5 : RingHomInvPair σ' σ], Function.Injective DFu... | true |
Mathlib.Tactic.Group.group | Mathlib.Tactic.Group | Lean.ParserDescr | true |
Std.Rxi.HasSize.casesOn | Init.Data.Range.Polymorphic.Basic | {α : Type u} →
{motive : Std.Rxi.HasSize α → Sort u_1} →
(t : Std.Rxi.HasSize α) → ((size : α → ℕ) → motive { size := size }) → motive t | false |
_private.Lean.Util.ReplaceLevel.0.Lean.Expr.ReplaceLevelImpl.replaceUnsafeM.match_1 | Lean.Util.ReplaceLevel | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((binderName : Lean.Name) →
(d b : Lean.Expr) → (binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName d b binderInfo)) →
((binderName : Lean.Name) →
(d b : Lean.Expr) → (binderInfo : Lean.BinderInfo) → motive (Lean.Expr.la... | false |
SeparationQuotient.instRing._proof_6 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : Ring R] [IsTopologicalRing R], ContinuousConstSMul ℤ R | false |
Congr!.plausiblyEqualTypes._unsafe_rec | Mathlib.Tactic.CongrExclamation | Lean.Expr → Lean.Expr → optParam ℕ 5 → Lean.MetaM Bool | false |
Std.DTreeMap.Internal.Impl.isEmpty_insertMany_list | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α] (h : t.WF)
{l : List ((a : α) × β a)}, (↑(t.insertMany l ⋯)).isEmpty = (t.isEmpty && l.isEmpty) | true |
MeasurableEq.mk | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u_1} [inst : MeasurableSpace α], MeasurableSet (Set.diagonal α) → MeasurableEq α | true |
instComplSubtypeProdAndEqHMulFstSndOfNatHAdd | Mathlib.Algebra.Order.Ring.Idempotent | {R : Type u_1} → [inst : CommMonoid R] → [inst_1 : AddCommMonoid R] → Compl { a // a.1 * a.2 = 0 ∧ a.1 + a.2 = 1 } | true |
_private.Mathlib.Analysis.Polynomial.MahlerMeasure.0.Polynomial.mahlerMeasure_X_add_C._simp_1_1 | Mathlib.Analysis.Polynomial.MahlerMeasure | ∀ {α : Type u_1} [inst : SubtractionMonoid α] (a b : α), a + b = a - -b | false |
_private.Batteries.Data.RBMap.Lemmas.0.Batteries.RBNode.balance1.match_1.splitter._sparseCasesOn_2 | Batteries.Data.RBMap.Lemmas | {α : Type u} →
{motive : Batteries.RBNode α → Sort u_1} →
(t : Batteries.RBNode α) →
((c : Batteries.RBColor) →
(l : Batteries.RBNode α) → (v : α) → (r : Batteries.RBNode α) → motive (Batteries.RBNode.node c l v r)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
Plausible.InjectiveFunction.instArbitraryInt | Mathlib.Testing.Plausible.Functions | Plausible.Arbitrary (Plausible.InjectiveFunction ℤ) | true |
HomotopicalAlgebra.CategoryWithCofibrations.recOn | Mathlib.AlgebraicTopology.ModelCategory.CategoryWithCofibrations | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{motive : HomotopicalAlgebra.CategoryWithCofibrations C → Sort u_1} →
(t : HomotopicalAlgebra.CategoryWithCofibrations C) →
((cofibrations : CategoryTheory.MorphismProperty C) → motive { cofibrations := cofibrations }) → motive t | false |
_private.Mathlib.MeasureTheory.Function.SimpleFunc.0.MeasureTheory.SimpleFunc.restrict_lintegral._simp_1_1 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] (f : MeasureTheory.SimpleFunc α β) (x : α),
(f x ∈ f.range) = True | false |
LieAlgebra.isNilpotent_ad_of_mem_rootSpace | Mathlib.Algebra.Lie.Weights.Chain | ∀ {L : Type u_2} [inst : LieRing L] {K : Type u_4} [inst_1 : Field K] [CharZero K] [inst_3 : LieAlgebra K L]
(H : LieSubalgebra K L) [inst_4 : LieRing.IsNilpotent ↥H] [LieModule.IsTriangularizable K (↥H) L]
[FiniteDimensional K L] {x : L} {χ : ↥H → K},
χ ≠ 0 → x ∈ LieAlgebra.rootSpace H χ → IsNilpotent ((LieAlgeb... | true |
Nat.isLeast_nth_of_infinite | Mathlib.Data.Nat.Nth | ∀ {p : ℕ → Prop}, (setOf p).Infinite → ∀ (n : ℕ), IsLeast {i | p i ∧ ∀ k < n, Nat.nth p k < i} (Nat.nth p n) | true |
CliffordAlgebra.reverseOp_ι | Mathlib.LinearAlgebra.CliffordAlgebra.Conjugation | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{Q : QuadraticForm R M} (m : M),
CliffordAlgebra.reverseOp ((CliffordAlgebra.ι Q) m) = MulOpposite.op ((CliffordAlgebra.ι Q) m) | true |
Std.Time.Modifier.s.noConfusion | Std.Time.Format.Basic | {P : Sort u} →
{presentation presentation' : Std.Time.Number} →
Std.Time.Modifier.s presentation = Std.Time.Modifier.s presentation' → (presentation = presentation' → P) → P | false |
Lean.Meta.Grind.mkExtension._auto_1 | Lean.Meta.Tactic.Grind.Extension | Lean.Syntax | false |
Lean.ScopedEnvExtension.ScopedEntries.casesOn | Lean.ScopedEnvExtension | {β : Type} →
{motive : Lean.ScopedEnvExtension.ScopedEntries β → Sort u} →
(t : Lean.ScopedEnvExtension.ScopedEntries β) →
((map : Lean.SMap Lean.Name (Lean.PArray β)) → motive { map := map }) → motive t | false |
NonUnitalSubsemiring.instSetLike | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | {R : Type u} → [inst : NonUnitalNonAssocSemiring R] → SetLike (NonUnitalSubsemiring R) R | true |
_private.Mathlib.CategoryTheory.Generator.Preadditive.0.CategoryTheory.Preadditive.isSeparating_iff._simp_1_1 | Mathlib.CategoryTheory.Generator.Preadditive | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | false |
Lean.Server.handleCodeActionResolve | Lean.Server.CodeActions.Basic | Lean.Lsp.CodeAction → Lean.Server.RequestM (Lean.Server.RequestTask Lean.Lsp.CodeAction) | true |
_private.Lean.Meta.Tactic.FunInd.0.Lean.Tactic.FunInd.M.tell | Lean.Meta.Tactic.FunInd | Lean.Expr → Lean.Tactic.FunInd.M✝ Unit | true |
Lean.Elab.Rewrites.evalExact._regBuiltin.Lean.Elab.Rewrites.evalExact.declRange_3 | Lean.Elab.Tactic.Rewrites | IO Unit | false |
Lean.Elab.Term.elabWithoutExpectedTypeAttr | Lean.Elab.App | Lean.TagAttribute | true |
PseudoMetricSpace.noConfusionType | Mathlib.Topology.MetricSpace.Pseudo.Defs | Sort u_1 → {α : Type u} → PseudoMetricSpace α → {α' : Type u} → PseudoMetricSpace α' → Sort u_1 | false |
Real.tendsto_rightDeriv_mul_log_atTop | Mathlib.Analysis.SpecialFunctions.Log.NegMulLog | Filter.Tendsto (fun x => derivWithin (fun x => x * Real.log x) (Set.Ioi x) x) Filter.atTop Filter.atTop | true |
Lean.Kernel.Exception.toMessageData | Lean.Message | Lean.Kernel.Exception → Lean.Options → Lean.MessageData | true |
Std.DTreeMap.Internal.Impl.getKeyD_alter! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Std.LawfulEqOrd α],
t.WF →
∀ {k k' fallback : α} {f : Option (β k) → Option (β k)},
(Std.DTreeMap.Internal.Impl.alter! k f t).getKeyD k' fallback =
if compare k k' = Ordering.eq then if ... | true |
Lean.Lsp.instFromJsonPartialResultParams | Lean.Data.Lsp.Basic | Lean.FromJson Lean.Lsp.PartialResultParams | true |
isOpen_sum_iff | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {s : Set (X ⊕ Y)},
IsOpen s ↔ IsOpen (Sum.inl ⁻¹' s) ∧ IsOpen (Sum.inr ⁻¹' s) | true |
UniformSpace.Completion.uniformSpace._proof_4 | Mathlib.Topology.UniformSpace.Completion | ∀ (α : Type u_1) [inst : UniformSpace α],
Filter.Tendsto Prod.swap
(Filter.map (Prod.map SeparationQuotient.mk SeparationQuotient.mk) (uniformity (CauchyFilter α)))
(Filter.map (Prod.map SeparationQuotient.mk SeparationQuotient.mk) (uniformity (CauchyFilter α))) | false |
Monoid.toMulAction._proof_2 | Mathlib.Algebra.Group.Action.Defs | ∀ (M : Type u_1) [inst : Monoid M] (a : M), 1 * a = a | false |
subsingleton_iff_zero_eq_one | Mathlib.Algebra.GroupWithZero.Basic | ∀ {M₀ : Type u_1} [inst : MulZeroOneClass M₀], 0 = 1 ↔ Subsingleton M₀ | true |
Lean.instEmptyCollectionPrefixTree | Lean.Data.PrefixTree | {α : Type u_1} → {β : Type u_2} → {p : α → α → Ordering} → EmptyCollection (Lean.PrefixTree α β p) | true |
Equiv.removeNone_aux_none | Mathlib.Logic.Equiv.Option | ∀ {α : Type u_1} {β : Type u_2} (e : Option α ≃ Option β) {x : α},
e (some x) = none → some (e.removeNone_aux x) = e none | true |
Int32.toISize_ofNat | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, n ≤ 2147483647 → (OfNat.ofNat n).toISize = OfNat.ofNat n | true |
MeasureTheory.eLpNormEssSup_le_of_ae_nnnorm_bound | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | ∀ {α : Type u_1} {F : Type u_5} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup F]
{f : α → F} {C : NNReal}, (∀ᵐ (x : α) ∂μ, ‖f x‖₊ ≤ C) → MeasureTheory.eLpNormEssSup f μ ≤ ↑C | true |
ZeroLEOneClass.rec | Mathlib.Algebra.Order.ZeroLEOne | {α : Type u_2} →
[inst : Zero α] →
[inst_1 : One α] →
[inst_2 : LE α] →
{motive : ZeroLEOneClass α → Sort u} → ((zero_le_one : 0 ≤ 1) → motive ⋯) → (t : ZeroLEOneClass α) → motive t | false |
UpperHalfPlane.IsZeroAtImInfty.petersson_isZeroAtImInfty_left | Mathlib.NumberTheory.ModularForms.Petersson | ∀ {F : Type u_1} {F' : Type u_2} [inst : FunLike F UpperHalfPlane ℂ] [inst_1 : FunLike F' UpperHalfPlane ℂ] (k : ℤ)
(Γ : Subgroup (GL (Fin 2) ℝ)) [Fact (IsCusp OnePoint.infty Γ)] [Γ.HasDetPlusMinusOne] [DiscreteTopology ↥Γ]
[ModularFormClass F Γ k] [ModularFormClass F' Γ k] {f : F},
UpperHalfPlane.IsZeroAtImInfty... | true |
List.Vector.instLawfulTraversableFlipNat | Mathlib.Data.Vector.Basic | ∀ {n : ℕ}, LawfulTraversable (flip List.Vector n) | true |
AddSubmonoid.instInfSet._proof_2 | Mathlib.Algebra.Group.Submonoid.Basic | ∀ {M : Type u_1} [inst : AddZeroClass M] (s : Set (AddSubmonoid M)) {a b : M},
a ∈ ⋂ t ∈ s, ↑t → b ∈ ⋂ t ∈ s, ↑t → a + b ∈ ⋂ x ∈ s, ↑x | false |
PFunctor.Approx.Agree.continu | Mathlib.Data.PFunctor.Univariate.M | ∀ {F : PFunctor.{uA, uB}} (x : PFunctor.Approx.CofixA F 0) (y : PFunctor.Approx.CofixA F 1), PFunctor.Approx.Agree x y | true |
SlashInvariantForm.constℝ._proof_1 | Mathlib.NumberTheory.ModularForms.SlashInvariantForms | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} [Γ.HasDetPlusMinusOne] (x : ℝ),
∀ g ∈ Γ,
∀ (τ : UpperHalfPlane),
SlashAction.map 0 g (Function.const UpperHalfPlane ↑x) τ = Function.const UpperHalfPlane (↑x) τ | false |
Eq.mpr_prop | Init.SimpLemmas | ∀ {p q : Prop}, p = q → q → p | true |
_private.Mathlib.Analysis.Analytic.Basic.0.HasFPowerSeriesWithinOnBall.congr._simp_1_1 | Mathlib.Analysis.Analytic.Basic | ∀ {α : Type u_1} {x a : α} {s : Set α}, (x ∈ insert a s) = (x = a ∨ x ∈ s) | false |
_private.Mathlib.Data.QPF.Multivariate.Basic.0.MvQPF.mem_supp._proof_1_1 | Mathlib.Data.QPF.Multivariate.Basic | ∀ {n : ℕ} {F : TypeVec.{u_1} n → Type u_2} [q : MvQPF F] {α : TypeVec.{u_1} n} (x : F α) (i : Fin2 n) (u : α i),
(∀ (a : (MvQPF.P F).A) (f : ((MvQPF.P F).B a).Arrow α), MvQPF.abs ⟨a, f⟩ = x → u ∈ f i '' Set.univ) →
∀ ⦃P : (i : Fin2 n) → α i → Prop⦄, MvFunctor.LiftP P x → P i u | false |
_private.Mathlib.Algebra.Lie.CartanExists.0.LieAlgebra.engel_isBot_of_isMin._simp_1_6 | Mathlib.Algebra.Lie.CartanExists | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (p : Submodule R M)
(h : ∀ {x : L} {m : M}, m ∈ p.carrier → ⁅x, m⁆ ∈ p.carrier) {x : M},
(x ∈ { toSubmodule := p, lie_mem := h }) = (x ∈ p) | false |
Lean.Meta.SynthInstance.Waiter.recOn | Lean.Meta.SynthInstance | {motive : Lean.Meta.SynthInstance.Waiter → Sort u} →
(t : Lean.Meta.SynthInstance.Waiter) →
((a : Lean.Meta.SynthInstance.ConsumerNode) → motive (Lean.Meta.SynthInstance.Waiter.consumerNode a)) →
motive Lean.Meta.SynthInstance.Waiter.root → motive t | false |
LieIdeal.lcs | Mathlib.Algebra.Lie.Nilpotent | {R : Type u_1} →
{L : Type u_2} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : LieAlgebra R L] →
LieIdeal R L →
(M : Type u_3) →
[inst_3 : AddCommGroup M] → [inst_4 : Module R M] → [inst_5 : LieRingModule L M] → ℕ → LieSubmodule R L M | true |
ExteriorAlgebra.ι | Mathlib.LinearAlgebra.ExteriorAlgebra.Basic | (R : Type u1) →
[inst : CommRing R] → {M : Type u2} → [inst_1 : AddCommGroup M] → [inst_2 : Module R M] → M →ₗ[R] ExteriorAlgebra R M | true |
AddSubmonoid.leftNeg | Mathlib.GroupTheory.Submonoid.Inverses | {M : Type u_1} → [inst : AddMonoid M] → AddSubmonoid M → AddSubmonoid M | true |
CategoryTheory.Bicategory.Adj.Hom.mk.inj | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | ∀ {B : Type u} {inst : CategoryTheory.Bicategory B} {a b : B} {l : a ⟶ b} {r : b ⟶ a}
{adj : CategoryTheory.Bicategory.Adjunction l r} {l_1 : a ⟶ b} {r_1 : b ⟶ a}
{adj_1 : CategoryTheory.Bicategory.Adjunction l_1 r_1},
{ l := l, r := r, adj := adj } = { l := l_1, r := r_1, adj := adj_1 } → l = l_1 ∧ r = r_1 ∧ adj... | true |
Matrix.projVandermonde_map | Mathlib.LinearAlgebra.Vandermonde | ∀ {R : Type u_1} [inst : CommRing R] {n : ℕ} {R' : Type u_3} [inst_1 : CommRing R'] (φ : R →+* R') (v w : Fin n → R),
(Matrix.projVandermonde (fun i => φ (v i)) fun i => φ (w i)) = φ.mapMatrix (Matrix.projVandermonde v w) | true |
CategoryTheory.Subobject.isoOfEqMk_inv | Mathlib.CategoryTheory.Subobject.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {B A : C} (X : CategoryTheory.Subobject B) (f : A ⟶ B)
[inst_1 : CategoryTheory.Mono f] (h : X = CategoryTheory.Subobject.mk f),
(X.isoOfEqMk f h).inv = CategoryTheory.Subobject.ofMkLE f X ⋯ | true |
Finset.noncommProd_singleton | Mathlib.Data.Finset.NoncommProd | ∀ {α : Type u_3} {β : Type u_4} [inst : Monoid β] (a : α) (f : α → β), {a}.noncommProd f ⋯ = f a | true |
_private.Mathlib.LinearAlgebra.Transvection.Basic.0.LinearEquiv.symm_mem_dilatransvections_iff._simp_1_1 | Mathlib.LinearAlgebra.Transvection.Basic | ∀ {G : Type u_1} [inst : SubNegMonoid G] (a b : G), a + -b = a - b | false |
_private.Mathlib.Algebra.Homology.HomotopyCategory.MappingCocone.0.CochainComplex.mappingCocone.inr_v_descCochain_v._proof_1_1 | Mathlib.Algebra.Homology.HomotopyCategory.MappingCocone | ∀ (p q : ℤ), p + 1 = q → p = q + -1 | false |
String.Pos.instLinearOrderPackage._proof_9 | Init.Data.String.OrderInstances | ∀ {s : String},
let this := inferInstance;
let this_1 := inferInstance;
let this_2 :=
let this := inferInstance;
let this_2 := inferInstance;
Max.leftLeaningOfLE s.Pos;
∀ (a b : s.Pos), a ⊔ b = if b ≤ a then a else b | false |
FirstOrder.Language.Theory.ModelsBoundedFormula.eq_1 | Mathlib.ModelTheory.Equivalence | ∀ {L : FirstOrder.Language} (T : L.Theory) {α : Type w} {n : ℕ} (φ : L.BoundedFormula α n),
T ⊨ᵇ φ = ∀ (M : T.ModelType) (v : α → ↑M) (xs : Fin n → ↑M), φ.Realize v xs | true |
ContinuousMap.mem_setOfIdeal | Mathlib.Topology.ContinuousMap.Ideals | ∀ {X : Type u_1} {R : Type u_2} [inst : TopologicalSpace X] [inst_1 : Semiring R] [inst_2 : TopologicalSpace R]
[inst_3 : IsTopologicalSemiring R] {I : Ideal C(X, R)} {x : X}, x ∈ ContinuousMap.setOfIdeal I ↔ ∃ f ∈ I, f x ≠ 0 | true |
PowerSeries.idealX._proof_1 | Mathlib.RingTheory.LaurentSeries | ∀ (K : Type u_1) [inst : Field K], Ideal.span {PowerSeries.X} ≠ ⊥ | false |
Lean.Parser.Command.prefix.formatter | Lean.Parser.Syntax | Lean.PrettyPrinter.Formatter | true |
Std.DTreeMap.Const.minKey?_modify_eq_minKey? | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] {k : α} {f : β → β}, (Std.DTreeMap.Const.modify t k f).minKey? = t.minKey? | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.