name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
ModuleCat.ExtendRestrictScalarsAdj.HomEquiv.fromExtendScalars._proof_4 | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] (f : R →+* S) {X : ModuleCat R}
{Y : ModuleCat S} (g : X ⟶ (ModuleCat.restrictScalars f).obj Y)
(a a_1 : TensorProduct R ↑((ModuleCat.restrictScalars f).obj (ModuleCat.of S S)) ↑X),
(TensorProduct.lift
{ toFun := fun s => ModuleCat.... | false |
Turing.TM0.Stmt.noConfusion | Mathlib.Computability.TuringMachine.PostTuringMachine | {P : Sort u} →
{Γ : Type u_1} →
{t : Turing.TM0.Stmt Γ} →
{Γ' : Type u_1} → {t' : Turing.TM0.Stmt Γ'} → Γ = Γ' → t ≍ t' → Turing.TM0.Stmt.noConfusionType P t t' | false |
_private.Mathlib.Computability.TuringMachine.Tape.0.Turing.Tape.write_nth.match_1_1 | Mathlib.Computability.TuringMachine.Tape | ∀ {Γ : Type u_1} [inst : Inhabited Γ] (motive : Turing.Tape Γ → ℤ → Prop) (x : Turing.Tape Γ) (x_1 : ℤ),
(∀ (x : Turing.Tape Γ), motive x 0) →
(∀ (x : Turing.Tape Γ) (n : ℕ), motive x (Int.ofNat n.succ)) →
(∀ (x : Turing.Tape Γ) (a : ℕ), motive x (Int.negSucc a)) → motive x x_1 | false |
HomologicalComplex₂.ofGradedObject | Mathlib.Algebra.Homology.HomologicalBicomplex | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{I₁ : Type u_2} →
{I₂ : Type u_3} →
(c₁ : ComplexShape I₁) →
(c₂ : ComplexShape I₂) →
(X : CategoryTheory.GradedObject (I₁ × I₂) C) →
... | true |
accPt_iff_frequently | Mathlib.Topology.ClusterPt | ∀ {X : Type u} [inst : TopologicalSpace X] {x : X} {C : Set X},
AccPt x (Filter.principal C) ↔ ∃ᶠ (y : X) in nhds x, y ≠ x ∧ y ∈ C | true |
_private.Init.Data.SInt.Lemmas.0.Int16.toNatClampNeg_ofNat_of_lt._proof_1_2 | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, n < 2 ^ 15 → ¬-2 ^ 15 ≤ ↑n → False | false |
FirstOrder._aux_Mathlib_ModelTheory_LanguageMap___unexpand_FirstOrder_Language_withConstants_1 | Mathlib.ModelTheory.LanguageMap | Lean.PrettyPrinter.Unexpander | false |
CategoryTheory.Limits.colimit.ι_desc_apply | Mathlib.CategoryTheory.ConcreteCategory.Elementwise | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasColimit F] (c : CategoryTheory.Limits.Cocone F)
(j : J) {F_1 : C → C → Type uF} {carrier : C → Type w}
{instFunLike : (X Y : C) →... | true |
Lean.Elab.Term.elabOmission | Lean.Elab.BuiltinTerm | Lean.Elab.Term.TermElab | true |
_private.Lean.Compiler.IR.ToIR.0.Lean.IR.ToIR.lowerDecl.match_1 | Lean.Compiler.IR.ToIR | (motive : Lean.Compiler.LCNF.DeclValue Lean.Compiler.LCNF.Purity.impure → Sort u_1) →
(x : Lean.Compiler.LCNF.DeclValue Lean.Compiler.LCNF.Purity.impure) →
((code : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.impure) →
motive (Lean.Compiler.LCNF.DeclValue.code code)) →
((externAttrData : Lean.... | false |
CategoryTheory.Limits.CoconeMorphism.inv_hom_id | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} {c d : CategoryTheory.Limits.Cocone F} (f : c ≅ d),
CategoryTheory.CategoryStruct.comp f.inv.hom f.hom.hom = CategoryTheory.CategoryStruct.id d.pt | true |
Pi.Function.module | Mathlib.Algebra.Module.Pi | (I : Type u) →
(α : Type u_1) → (β : Type u_2) → [inst : Semiring α] → [inst_1 : AddCommMonoid β] → [Module α β] → Module α (I → β) | true |
Ideal.sup_height_eq_ringKrullDim | Mathlib.RingTheory.Ideal.Height | ∀ {R : Type u_1} [inst : CommRing R] [Nontrivial R], ↑(⨆ I, ⨆ (_ : I ≠ ⊤), I.height) = ringKrullDim R | true |
Std.DTreeMap.foldlM_eq_foldlM_keys | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} {δ : Type w} {m : Type w → Type w'}
[inst : Monad m] [LawfulMonad m] {f : δ → α → m δ} {init : δ},
Std.DTreeMap.foldlM (fun d a x => f d a) init t = List.foldlM f init t.keys | true |
ExistsAndEq.withExistsElimAlongPathImp._unsafe_rec | Mathlib.Tactic.Simproc.ExistsAndEq | {u : Lean.Level} →
{α : Q(Sort u)} →
{P goal : Q(Prop)} →
Q(«$P») →
{a a' : Q(«$α»)} →
List ExistsAndEq.VarQ →
ExistsAndEq.Path →
List ExistsAndEq.HypQ →
(Q(«$a» = «$a'») → List ExistsAndEq.HypQ → Lean.MetaM Q(«$goal»)) → Lean.MetaM Q(«$goal») | false |
Commute.self_pow | Mathlib.Algebra.Group.Commute.Defs | ∀ {M : Type u_2} [inst : Monoid M] (a : M) (n : ℕ), Commute a (a ^ n) | true |
bilinearIteratedFDerivTwo.eq_1 | Mathlib.Analysis.InnerProductSpace.Laplacian | ∀ (𝕜 : 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), bilinearIteratedFDerivTwo 𝕜 f x = (fderiv 𝕜 (fderiv 𝕜 f) x).toLinearMap₁₂ | true |
Std.TreeMap.get!_union | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α}
[inst : Inhabited β], (t₁ ∪ t₂).get! k = t₂.getD k (t₁.get! k) | true |
_private.Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar.0.MeasureTheory.Measure.tendsto_addHaar_inter_smul_zero_of_density_zero_aux2._simp_1_1 | Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar | ∀ {α : Type u_1} [inst : AddGroup α] [inst_1 : LinearOrder α] [AddLeftMono α] {a : α} [AddRightMono α],
(|a| ≤ 0) = (a = 0) | false |
_private.Lean.Elab.DocString.0.Lean.Doc.instMonadLiftTermElabMDocM.match_1 | Lean.Elab.DocString | (motive : Lean.Doc.State → Sort u_1) →
(__do_lift : Lean.Doc.State) →
((scopes : List Lean.Elab.Command.Scope) →
(openDecls : List Lean.OpenDecl) →
(lctx : Lean.LocalContext) →
(localInstances : Lean.LocalInstances) →
(options : Lean.Options) →
motive
... | false |
Lean.InternalExceptionId.toString | Lean.InternalExceptionId | Lean.InternalExceptionId → String | true |
Polynomial.isMonicOfDegree_sub_add_two | Mathlib.Algebra.Polynomial.Degree.IsMonicOfDegree | ∀ {R : Type u_1} [inst : Ring R] [Nontrivial R] (a b : R),
(Polynomial.X ^ 2 - Polynomial.C a * Polynomial.X + Polynomial.C b).IsMonicOfDegree 2 | true |
Booleanisation.instTop | Mathlib.Order.Booleanisation | {α : Type u_1} → [GeneralizedBooleanAlgebra α] → Top (Booleanisation α) | true |
Asymptotics.isLittleO_abs_right | Mathlib.Analysis.Asymptotics.Defs | ∀ {α : Type u_1} {E : Type u_3} [inst : Norm E] {f : α → E} {l : Filter α} {u : α → ℝ},
(f =o[l] fun x => |u x|) ↔ f =o[l] u | true |
Cubic.disc_eq_prod_three_roots | Mathlib.Algebra.CubicDiscriminant | ∀ {F : Type u_3} {K : Type u_4} {P : Cubic F} [inst : Field F] [inst_1 : Field K] {φ : F →+* K} {x y z : K},
P.a ≠ 0 → (Cubic.map φ P).roots = {x, y, z} → φ P.discr = (φ P.a * φ P.a * (x - y) * (x - z) * (y - z)) ^ 2 | true |
Lean.Firefox.ThreadWithCollideMaps.toThreadWithMaps | Lean.Util.Profiler | Lean.Firefox.ThreadWithCollideMaps → Lean.Firefox.ThreadWithMaps | true |
ContinuousLinearMap.toContinuousAffineMap._proof_2 | Mathlib.Topology.Algebra.ContinuousAffineMap | ∀ {R : Type u_3} {V : Type u_1} {W : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup V] [inst_2 : Module R V]
[inst_3 : TopologicalSpace V] [inst_4 : AddCommGroup W] [inst_5 : Module R W] [inst_6 : TopologicalSpace W]
(f : V →L[R] W), Continuous (↑f).toFun | false |
CategoryTheory.PreZeroHypercover.interFst._proof_2 | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {S : C} (E : CategoryTheory.PreZeroHypercover S)
(F : CategoryTheory.PreZeroHypercover S)
[inst_1 : ∀ (i : E.I₀) (j : F.I₀), CategoryTheory.Limits.HasPullback (E.f i) (F.f j)] (x : (E.inter F).I₀),
CategoryTheory.Limits.HasPullback (E.f ((Equiv.sigmaE... | false |
Dynamics.netEntropyEntourage_le_coverEntropyEntourage | Mathlib.Dynamics.TopologicalEntropy.NetEntropy | ∀ {X : Type u_1} {U : SetRel X X} (T : X → X) (F : Set X),
Dynamics.netEntropyEntourage T F U ≤ Dynamics.coverEntropyEntourage T F U | true |
CategoryTheory.PreZeroHypercover.sumInl._proof_2 | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {S : C} (E : CategoryTheory.PreZeroHypercover S)
(F : CategoryTheory.PreZeroHypercover S) (i : E.I₀),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id (E.X i)) ((E.sum F).f (Sum.inl i)) = E.f i | false |
_private.Lean.Meta.Sym.InstantiateS.0.Lean.Meta.Sym.instantiateRevBetaS'.visit.match_1 | Lean.Meta.Sym.InstantiateS | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((a : Lean.Literal) → e = Lean.Expr.lit a → motive (Lean.Expr.lit a)) →
((mvarId : Lean.MVarId) → e = Lean.Expr.mvar mvarId → motive (Lean.Expr.mvar mvarId)) →
((fvarId : Lean.FVarId) → e = Lean.Expr.fvar fvarId → motive (Lean.Expr.fvar fvarId)) →
... | false |
Lean.Meta.Sym.Simp.Context | Lean.Meta.Sym.Simp.SimpM | Type | true |
BitVec.getLsb | Init.Data.BitVec.Basic | {w : ℕ} → BitVec w → Fin w → Bool | true |
SheafOfModules.freeFunctor._proof_2 | Mathlib.Algebra.Category.ModuleCat.Sheaf.Free | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} [inst_1 : CategoryTheory.HasWeakSheafify J AddCommGrpCat]
[inst_2 : J.WEqualsLocallyBijective AddCommGrpCat]
[inst_3 : J.HasSheafCompose (CategoryTheory.forget₂ RingCat A... | false |
CategoryTheory.Pseudofunctor.ObjectProperty.noConfusionType | Mathlib.CategoryTheory.Bicategory.Functor.Cat.ObjectProperty | Sort u_1 →
{B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{F : CategoryTheory.Pseudofunctor B CategoryTheory.Cat} →
F.ObjectProperty →
{B' : Type u} →
[inst' : CategoryTheory.Bicategory B'] →
{F' : CategoryTheory.Pseudofunctor B' CategoryTheory.Cat} → F'.Ob... | false |
LinearIsometryEquiv.conjStarAlgEquiv._proof_8 | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {H : Type u_2} [inst_1 : NormedAddCommGroup H] [inst_2 : InnerProductSpace 𝕜 H],
ContinuousConstSMul 𝕜 H | false |
PreTilt.instCommRing._proof_27 | Mathlib.RingTheory.Perfection | ∀ (O : Type u_1) [inst : CommRing O] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : Fact ¬IsUnit ↑p],
autoParam (∀ (n : ℕ), ↑(n + 1) = ↑n + 1) AddMonoidWithOne.natCast_succ._autoParam | false |
Std.Tactic.BVDecide.BoolExpr.toString._unsafe_rec | Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic | {α : Type} → [ToString α] → Std.Tactic.BVDecide.BoolExpr α → String | false |
Int.Linear.Poly.coeff_k.eq_1 | Init.Data.Int.Linear | ∀ (p : Int.Linear.Poly) (x : Int.Linear.Var),
p.coeff_k x = Int.Linear.Poly.rec (fun x => 0) (fun a y x_1 ih => Bool.rec ih a (Nat.beq x y)) p | true |
ENat.coe_ne_top._simp_2 | Mathlib.Tactic.ENatToNat | ∀ (a : ℕ), (↑a = ⊤) = False | false |
CategoryTheory.Discrete.productEquiv._proof_15 | Mathlib.CategoryTheory.Discrete.SumsProducts | ∀ {J : Type u_2} {K : Type u_1} (X : CategoryTheory.Discrete (J × K)),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Discrete.functor fun x =>
match x with
| (j, k) => ({ as := j }, { as := k })).map
((CategoryTheory.NatIso.ofComponents
(fun x => CategoryThe... | false |
CategoryTheory.MonoidalCategory.ofTensorHom._auto_9 | Mathlib.CategoryTheory.Monoidal.Category | Lean.Syntax | false |
CategoryTheory.Sum.associativityFunctorEquivNaturalityFunctorIso_hom_app_snd_fst | Mathlib.CategoryTheory.Sums.Products | ∀ {A : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} A] {A' : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} A'] {B : Type u} [inst_2 : CategoryTheory.Category.{v, u} B]
(T : Type u_3) [inst_3 : CategoryTheory.Category.{v_3, u_3} T] (X : CategoryTheory.Functor ((A ⊕ A') ⊕ T) B),
((CategoryTheory.Su... | true |
Equiv.sumEmpty | Mathlib.Logic.Equiv.Sum | (α : Type u_9) → (β : Type u_10) → [IsEmpty β] → α ⊕ β ≃ α | true |
AlgebraicGeometry.IsReduced.mk | Mathlib.AlgebraicGeometry.Properties | ∀ {X : AlgebraicGeometry.Scheme},
autoParam (∀ (U : X.Opens), IsReduced ↑(X.presheaf.obj (Opposite.op U)))
AlgebraicGeometry.IsReduced.component_reduced._autoParam →
AlgebraicGeometry.IsReduced X | true |
_private.Lean.Meta.ExprLens.0.Lean.Core.viewBindersCoord._sparseCasesOn_2 | Lean.Meta.ExprLens | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) →
(type value body : Lean.Expr) → (nondep : Bool) → motive (Lean.Expr.letE declName type value body nondep)) →
(Nat.hasNotBit 256 t.ctorIdx → motive t) → motive t | false |
HomologicalComplex.mapBifunctor₂₃.D₂ | Mathlib.Algebra.Homology.BifunctorAssociator | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{C₂₃ : Type u_4} →
{C₃ : Type u_5} →
{C₄ : Type u_6} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] →
[inst_2 : CategoryTheory.Category.{v_3, u_5} C₃] →
[inst_... | true |
_private.Mathlib.MeasureTheory.Function.SimpleFuncDenseLp.0.MeasureTheory.SimpleFunc.memLp_approxOn._simp_1_2 | Mathlib.MeasureTheory.Function.SimpleFuncDenseLp | ∀ {E : Type u_5} [inst : SeminormedAddCommGroup E] (a b : E), ‖a - b‖ = dist a b | false |
ENNReal.HolderTriple.inv_le_inv | Mathlib.Data.ENNReal.Holder | ∀ (p q r : ENNReal) [p.HolderTriple q r], p⁻¹ ≤ r⁻¹ | true |
CovBy.coe_fin | Mathlib.Data.Nat.SuccPred | ∀ {n : ℕ} {a b : Fin n}, a ⋖ b → ↑a ⋖ ↑b | true |
List.isSome_max?_of_mem | Init.Data.List.MinMax | ∀ {α : Type u_1} {l : List α} [inst : Max α] {a : α}, a ∈ l → l.max?.isSome = true | true |
_private.Lean.Server.CodeActions.UnknownIdentifier.0.Lean.Server.FileWorker.handleUnknownIdentifierCodeAction.match_1 | Lean.Server.CodeActions.UnknownIdentifier | (motive : Option String.Pos.Raw → Sort u_1) →
(x : Option String.Pos.Raw) →
((headerTailPos : String.Pos.Raw) → motive (some headerTailPos)) → (Unit → motive none) → motive x | false |
instSetLikeSubRootedTreeα._proof_3 | Mathlib.Order.SuccPred.Tree | ∀ (t : RootedTree) (a₁ a₂ : SubRootedTree t), (fun v => Set.Ici v.root) a₁ = (fun v => Set.Ici v.root) a₂ → a₁ = a₂ | false |
IsCentralVAdd.mk._flat_ctor | Mathlib.Algebra.Group.Action.Defs | ∀ {M : Type u_9} {α : Type u_10} [inst : VAdd M α] [inst_1 : VAdd Mᵃᵒᵖ α],
(∀ (m : M) (a : α), AddOpposite.op m +ᵥ a = m +ᵥ a) → IsCentralVAdd M α | false |
Lean.Elab.TermInfo.recOn | Lean.Elab.InfoTree.Types | {motive : Lean.Elab.TermInfo → Sort u} →
(t : Lean.Elab.TermInfo) →
((toElabInfo : Lean.Elab.ElabInfo) →
(lctx : Lean.LocalContext) →
(expectedType? : Option Lean.Expr) →
(expr : Lean.Expr) →
(isBinder isDisplayableTerm : Bool) →
motive
... | false |
_private.Mathlib.RingTheory.Localization.NumDen.0.IsFractionRing.isUnit_den_zero._simp_1_2 | Mathlib.RingTheory.Localization.NumDen | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] [inst_2 : Algebra R S],
IsLocalization.IsInteger R 0 = True | false |
IsAlgebraic.algebraMap | Mathlib.RingTheory.Algebraic.Basic | ∀ {R : Type u} {S : Type u_1} {A : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Ring A]
[inst_3 : Algebra R A] [inst_4 : Algebra R S] [inst_5 : Algebra S A] [IsScalarTower R S A] {a : S},
IsAlgebraic R a → IsAlgebraic R ((algebraMap S A) a) | true |
CategoryTheory.Precoverage.ZeroHypercover.Small.casesOn | Mathlib.CategoryTheory.Sites.Hypercover.Zero | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.Precoverage C} →
{S : C} →
{E : J.ZeroHypercover S} →
{motive : E.Small → Sort u_1} →
(t : E.Small) →
((exists_restrictIndex_mem : ∃ ι f, (E.restrictIndex f).presieve₀ ∈ J.coverings S) ... | false |
CategoryTheory.Limits.epi_image_of_epi | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasImage f] [E : CategoryTheory.Epi f],
CategoryTheory.Epi (CategoryTheory.Limits.image.ι f) | true |
Nat.infinite_odd_deficient | Mathlib.NumberTheory.FactorisationProperties | {n | Odd n ∧ n.Deficient}.Infinite | true |
Ordinal.nfp_zero | Mathlib.SetTheory.Ordinal.FixedPoint | Ordinal.nfp 0 = id | true |
String.eq_empty_iff_forall_eq | Init.Data.String.Lemmas.IsEmpty | ∀ {s : String}, s = "" ↔ ∀ (p q : s.Pos), p = q | true |
Std.Internal.List.getKey?_eq_getEntry? | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] {l : List ((a : α) × β a)} {a : α},
Std.Internal.List.getKey? a l = Option.map (fun x => x.fst) (Std.Internal.List.getEntry? a l) | true |
Int.radical_natCast | Mathlib.RingTheory.Radical.NatInt | ∀ {n : ℕ}, UniqueFactorizationMonoid.radical ↑n = ↑(UniqueFactorizationMonoid.radical n) | true |
DilationEquiv.smulTorsor._proof_3 | Mathlib.Analysis.Normed.Affine.AddTorsor | ∀ {𝕜 : Type u_3} {E : Type u_2} [inst : NormedDivisionRing 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : Module 𝕜 E]
[NormSMulClass 𝕜 E] {P : Type u_1} [inst_4 : PseudoMetricSpace P] [inst_5 : NormedAddTorsor E P] (c : P) {k : 𝕜}
(x y : E), edist (k • x +ᵥ c) (k • y +ᵥ c) = ↑‖k‖₊ * edist x y | false |
Sym.fill | Mathlib.Data.Sym.Basic | {α : Type u_1} → {n : ℕ} → α → (i : Fin (n + 1)) → Sym α (n - ↑i) → Sym α n | true |
Matrix.toLinearMap₂'Aux._proof_2 | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ {R₁ : Type u_7} {S₁ : Type u_6} {R₂ : Type u_5} {S₂ : Type u_4} {N₂ : Type u_1} {n : Type u_2} {m : Type u_3}
[inst : Semiring R₁] [inst_1 : Semiring S₁] [inst_2 : Semiring R₂] [inst_3 : Semiring S₂] [inst_4 : AddCommMonoid N₂]
[inst_5 : Module S₁ N₂] [inst_6 : Module S₂ N₂] [SMulCommClass S₂ S₁ N₂] [inst_8 : Fin... | false |
FreeLieAlgebra.Rel.lie_self | Mathlib.Algebra.Lie.Free | ∀ {R : Type u} {X : Type v} [inst : CommRing R] (a : FreeNonUnitalNonAssocAlgebra R X), FreeLieAlgebra.Rel R X (a * a) 0 | true |
DirectLimit.instSemifieldOfRingHomClass._proof_3 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] [inst_4 : Nonempty ι]
[inst_5 : (... | false |
CochainComplex.mappingCone.map.congr_simp | Mathlib.Algebra.Homology.HomotopyCategory.Pretriangulated | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {K₁ L₁ K₂ L₂ : CochainComplex C ℤ} (φ₁ : K₁ ⟶ L₁)
(φ₂ : K₂ ⟶ L₂) (a a_1 : K₁ ⟶ K₂) (e_a : a = a_1) (b b_1 : L₁ ⟶ L₂) (e_b : b = b_1)
(comm : CategoryTheory.... | true |
iteratedFDerivWithin_eq_iteratedFDeriv | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
{f : E → F} {x : E} {n : ℕ},
UniqueDiffOn 𝕜 s → ContDiffAt 𝕜 (↑n) f x → x ∈ s → iteratedFDerivWithin... | true |
Algebra.IsStandardSmooth.mk | Mathlib.RingTheory.Smooth.StandardSmooth | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
(∃ ι σ, ∃ (x : Finite σ), Finite ι ∧ Nonempty (Algebra.SubmersivePresentation R S ι σ)) → Algebra.IsStandardSmooth R S | true |
CategoryTheory.shrinkYonedaEquiv_shrinkYoneda_map | Mathlib.CategoryTheory.ShrinkYoneda | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.LocallySmall.{w, v, u} C] {X Y : C}
(f : X ⟶ Y),
CategoryTheory.shrinkYonedaEquiv (CategoryTheory.shrinkYoneda.{w, v, u}.map f) =
CategoryTheory.shrinkYonedaObjObjEquiv.symm f | true |
skyscraperPresheafCoconeOfSpecializes | Mathlib.Topology.Sheaves.Skyscraper | {X : TopCat} →
(p₀ : ↑X) →
[inst : (U : TopologicalSpace.Opens ↑X) → Decidable (p₀ ∈ U)] →
{C : Type v} →
[inst_1 : CategoryTheory.Category.{u, v} C] →
(A : C) →
[inst_2 : CategoryTheory.Limits.HasTerminal C] →
{y : ↑X} →
p₀ ⤳ y →
... | true |
CategoryTheory.instInhabitedFreeMonoidalCategory.default | Mathlib.CategoryTheory.Monoidal.Free.Basic | {a : Type u_1} → CategoryTheory.FreeMonoidalCategory a | true |
TestFunction.instZero._proof_1 | Mathlib.Analysis.Distribution.TestFunction | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {F : Type u_2} [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] {n : ℕ∞}, ContDiff ℝ ↑n fun x => 0 | false |
CompactlySupportedContinuousMap.toReal_apply | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {α : Type u_2} [inst : TopologicalSpace α] (f : CompactlySupportedContinuousMap α NNReal) (x : α), f.toReal x = ↑(f x) | true |
Aesop.mvarIdToSubgoal | Aesop.RuleTac.Basic | Lean.MVarId → Lean.MVarId → Aesop.BaseM Aesop.Subgoal | true |
OpenNormalAddSubgroup.instSetLike | Mathlib.Topology.Algebra.OpenSubgroup | {G : Type u} → [inst : AddGroup G] → [inst_1 : TopologicalSpace G] → SetLike (OpenNormalAddSubgroup G) G | true |
Std.HashMap.Raw.Equiv.of_forall_getKey?_unit_eq | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α] [LawfulHashable α] {m₁ m₂ : Std.HashMap.Raw α Unit},
m₁.WF → m₂.WF → (∀ (k : α), m₁.getKey? k = m₂.getKey? k) → m₁.Equiv m₂ | true |
ContinuousAlternatingMap.toContinuousMultilinearMap_zero | Mathlib.Topology.Algebra.Module.Alternating.Basic | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_4} {ι : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : TopologicalSpace M] [inst_4 : AddCommMonoid N] [inst_5 : Module R N]
[inst_6 : TopologicalSpace N], ContinuousAlternatingMap.toContinuousMultilinearMap 0 = 0 | true |
ArchimedeanClass.FiniteResidueField.instArchimedean | Mathlib.Algebra.Order.Ring.StandardPart | ∀ {K : Type u_1} [inst : LinearOrder K] [inst_1 : Field K] [inst_2 : IsOrderedRing K],
Archimedean (ArchimedeanClass.FiniteResidueField K) | true |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.FinalizeContext.lctx | Lean.Elab.MutualInductive | Lean.Elab.Command.FinalizeContext✝ → Lean.LocalContext | true |
FirstOrder.Language.Theory.Model.realize_of_mem | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {M : Type w} {inst : L.Structure M} {T : L.Theory} [self : M ⊨ T], ∀ φ ∈ T, M ⊨ φ | true |
and_imp._simp_1 | Init.SimpLemmas | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | false |
_private.Lean.Meta.DecLevel.0.Lean.Meta.decAux?.match_8 | Lean.Meta.DecLevel | (motive : Lean.Level → Sort u_1) →
(x : Lean.Level) →
(Unit → motive Lean.Level.zero) →
((a : Lean.Name) → motive (Lean.Level.param a)) →
((mvarId : Lean.LMVarId) → motive (Lean.Level.mvar mvarId)) →
((u : Lean.Level) → motive u.succ) → ((u : Lean.Level) → motive u) → motive x | false |
_private.Lean.DocString.Extension.0.Lean.VersoModuleDocs.DocFrame.mk.sizeOf_spec | Lean.DocString.Extension | ∀ (content : Array (Lean.Doc.Block Lean.ElabInline Lean.ElabBlock))
(priorParts : Array (Lean.Doc.Part Lean.ElabInline Lean.ElabBlock Empty)) (titleString : String)
(title : Array (Lean.Doc.Inline Lean.ElabInline)),
sizeOf { content := content, priorParts := priorParts, titleString := titleString, title := title ... | true |
Std.TreeMap.Raw.modify | Std.Data.TreeMap.Raw.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → Std.TreeMap.Raw α β cmp → α → (β → β) → Std.TreeMap.Raw α β cmp | true |
AlgebraicGeometry.Scheme.AffineZariskiSite.mem_grothendieckTopology | Mathlib.AlgebraicGeometry.Sites.SmallAffineZariski | ∀ {X : AlgebraicGeometry.Scheme} {U : X.AffineZariskiSite} {S : CategoryTheory.Sieve U},
S ∈ (AlgebraicGeometry.Scheme.AffineZariskiSite.grothendieckTopology X) U ↔
∀ x ∈ U.toOpens, ∃ V f, S.arrows f ∧ x ∈ V.toOpens | true |
List.isPrefixOfAux_toArray_succ' | Init.Data.List.ToArray | ∀ {α : Type u_1} [inst : BEq α] (l₁ l₂ : List α) (hle : l₁.length ≤ l₂.length) (i : ℕ),
l₁.toArray.isPrefixOfAux l₂.toArray hle (i + 1) =
(List.drop (i + 1) l₁).toArray.isPrefixOfAux (List.drop (i + 1) l₂).toArray ⋯ 0 | true |
AdjoinRoot.coe_ofAlgHom | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommSemiring S] [inst_2 : Algebra S R] (p : Polynomial R),
⇑(AdjoinRoot.ofAlgHom S p) = ⇑(AdjoinRoot.of p) | true |
ProofWidgets.HtmlDisplayProps.mk.sizeOf_spec | ProofWidgets.Component.HtmlDisplay | ∀ (html : ProofWidgets.Html), sizeOf { html := html } = 1 + sizeOf html | true |
MeasureTheory.Filtration.IsRightContinuous.RC | Mathlib.Probability.Process.Filtration | ∀ {Ω : Type u_1} {ι : Type u_2} {m : MeasurableSpace Ω} {inst : PartialOrder ι} {𝓕 : MeasureTheory.Filtration ι m}
[self : 𝓕.IsRightContinuous], 𝓕.rightCont ≤ 𝓕 | true |
LinearEquiv.domMulActCongrRight._proof_5 | Mathlib.Algebra.Module.Equiv.Basic | ∀ {R₁ : Type u_4} {R₁' : Type u_5} {R₂' : Type u_6} {M₁ : Type u_2} {M₁' : Type u_1} {M₂' : Type u_3}
[inst : Semiring R₁] [inst_1 : Semiring R₁'] [inst_2 : Semiring R₂'] [inst_3 : AddCommMonoid M₁]
[inst_4 : AddCommMonoid M₁'] [inst_5 : AddCommMonoid M₂'] [inst_6 : Module R₁ M₁] [inst_7 : Module R₁' M₁']
[inst_8... | false |
AddMagma.FreeAddSemigroup.map.eq_1 | Mathlib.Algebra.Free | ∀ {α : Type u} [inst : Add α] {β : Type v} [inst_1 : Add β] (f : α →ₙ+ β),
AddMagma.FreeAddSemigroup.map f = AddMagma.FreeAddSemigroup.lift (AddMagma.FreeAddSemigroup.of.comp f) | true |
AntitoneOn.map_bddBelow | Mathlib.Order.Bounds.Image | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β} {s t : Set α},
AntitoneOn f t → s ⊆ t → (lowerBounds s ∩ t).Nonempty → BddAbove (f '' s) | true |
Lean.Grind.Linarith.Poly.NonnegCoeffs.add | Init.Grind.Module.NatModuleNorm | ∀ (a : ℤ) (x : Lean.Grind.Linarith.Var) (p : Lean.Grind.Linarith.Poly),
a ≥ 0 → p.NonnegCoeffs → (Lean.Grind.Linarith.Poly.add a x p).NonnegCoeffs | true |
Function.Surjective.mulActionWithZero | Mathlib.Algebra.GroupWithZero.Action.Defs | {M₀ : Type u_2} →
{A : Type u_7} →
{A' : Type u_8} →
[inst : MonoidWithZero M₀] →
[inst_1 : Zero A] →
[inst_2 : MulActionWithZero M₀ A] →
[inst_3 : Zero A'] →
[inst_4 : SMul M₀ A'] →
(f : ZeroHom A A') →
Function.Surjective ⇑f → (... | true |
Finsupp.split_apply | Mathlib.Data.Finsupp.Basic | ∀ {ι : Type u_4} {M : Type u_5} {αs : ι → Type u_12} [inst : Zero M] (l : (i : ι) × αs i →₀ M) (i : ι) (x : αs i),
(l.split i) x = l ⟨i, x⟩ | true |
Ideal.associatesEquivIsPrincipal._proof_3 | Mathlib.RingTheory.Ideal.IsPrincipal | ∀ (R : Type u_1) [inst : CommRing R] (I : { I // Submodule.IsPrincipal I }), Submodule.IsPrincipal ↑I | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.