name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Init.Data.Array.Basic.0.Array.findSomeRevM?.find.match_1 | Init.Data.Array.Basic | {β : Type u_1} →
(motive : Option β → Sort u_2) → (r : Option β) → ((val : β) → motive (some val)) → (Unit → motive none) → motive r | null | false |
normalize_eq_one | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : MonoidWithZero α] [inst_1 : NormalizationMonoid α] {x : α}, normalize x = 1 ↔ IsUnit x | null | true |
_private.Mathlib.MeasureTheory.Integral.Bochner.Basic.0.Mathlib.Meta.Positivity.evalIntegral._proof_2 | Mathlib.MeasureTheory.Integral.Bochner.Basic | ∀ (α : Q(Type)) (pα : Q(PartialOrder «$α»)) (__defeqres : PLift («$pα» =Q Real.partialOrder)),
«$pα» =Q Real.partialOrder | null | false |
Matrix.Semiring.smulCommClass | Mathlib.Data.Matrix.Mul | ∀ {n : Type u_3} {R : Type u_5} {α : Type v} [inst : NonUnitalNonAssocSemiring α] [inst_1 : Fintype n]
[inst_2 : Monoid R] [inst_3 : DistribMulAction R α] [SMulCommClass R α α],
SMulCommClass R (Matrix n n α) (Matrix n n α) | This instance enables use with `mul_smul_comm`. | true |
Std.Time.Day.instDecidableLtOffset._aux_1 | Std.Time.Date.Unit.Day | {x y : Std.Time.Day.Offset} → Decidable (x < y) | null | false |
CFC.norm_mul_mul_star_self_of_nonneg | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Isometric | ∀ {A : Type u_1} [inst : PartialOrder A] [inst_1 : NonUnitalNormedRing A] [inst_2 : StarRing A] [CStarRing A]
[inst_4 : NormedSpace ℝ A] [inst_5 : SMulCommClass ℝ A A] [inst_6 : IsScalarTower ℝ A A] [inst_7 : StarOrderedRing A]
[inst_8 : NonUnitalContinuousFunctionalCalculus ℝ A IsSelfAdjoint] [inst_9 : NonnegSpect... | null | true |
_private.Lean.Compiler.LCNF.Simp.JpCases.0.Lean.Compiler.LCNF.Simp.mkJmpArgsAtJp | Lean.Compiler.LCNF.Simp.JpCases | Array (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure) →
ℕ →
Array (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure) →
Bool → Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure) | Create the arguments for a jump to an auxiliary join point created using `mkJpAlt`.
This function is used to create jumps from the join point satisfying `isJpCases?` to the new auxiliary join points created using `mkJpAlt`.
| true |
_private.Mathlib.Order.LiminfLimsup.0.CompleteLatticeHom.apply_limsup_iterate._simp_1_1 | Mathlib.Order.LiminfLimsup | ∀ (n m : ℕ), (n + m).succ = n + m.succ | null | false |
sigmaFinsuppAddEquivDFinsupp._proof_2 | Mathlib.Data.Finsupp.ToDFinsupp | ∀ {ι : Type u_3} {η : ι → Type u_2} {N : Type u_1} [inst : AddZeroClass N],
Function.RightInverse sigmaFinsuppEquivDFinsupp.invFun sigmaFinsuppEquivDFinsupp.toFun | null | false |
_private.Mathlib.Tactic.Ring.Basic.0.Mathlib.Tactic.Ring.cast_neg.match_1_1 | Mathlib.Tactic.Ring.Basic | ∀ {n : ℕ} {R : Type u_1} [inst : Ring R] {a : R} (motive : Mathlib.Meta.NormNum.IsInt a (Int.negOfNat n) → Prop)
(x : Mathlib.Meta.NormNum.IsInt a (Int.negOfNat n)), (∀ (e : a = ↑(Int.negOfNat n)), motive ⋯) → motive x | null | false |
IsUniformAddGroup.isLeftUniformAddGroup | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ (α : Type u_1) [inst : UniformSpace α] [inst_1 : AddGroup α] [IsUniformAddGroup α], IsLeftUniformAddGroup α | null | true |
Action.inv_hom_hom_assoc | Mathlib.CategoryTheory.Action.Basic | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} V] {G : Type u_2} [inst_1 : Monoid G] {M N : Action V G}
(f : M ≅ N) {Z : V} (h : N.V ⟶ Z),
CategoryTheory.CategoryStruct.comp f.inv.hom (CategoryTheory.CategoryStruct.comp f.hom.hom h) = h | null | true |
_private.Mathlib.Algebra.Group.Monoid.0.IsLeftRegular.mul_eq_one_symm._simp_1_1 | Mathlib.Algebra.Group.Monoid | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c | null | false |
_private.Mathlib.Analysis.Complex.PhragmenLindelof.0._aux_Mathlib_Analysis_Complex_PhragmenLindelof___macroRules__private_Mathlib_Analysis_Complex_PhragmenLindelof_0_termExpR_1 | Mathlib.Analysis.Complex.PhragmenLindelof | Lean.Macro | null | false |
instCommRingCorner._proof_2 | Mathlib.RingTheory.Idempotents | ∀ {R : Type u_1} (e : R) [inst : NonUnitalCommRing R] (idem : IsIdempotentElem e) (a b : idem.Corner), a * b = b * a | null | false |
Complex.cpow_two | Mathlib.Analysis.SpecialFunctions.Pow.Complex | ∀ (x : ℂ), x ^ 2 = x ^ 2 | null | true |
Lean.Elab.Tactic.ElabSimpArgsResult.mk.inj | Lean.Elab.Tactic.Simp | ∀ {ctx : Lean.Meta.Simp.Context} {simprocs : Lean.Meta.Simp.SimprocsArray}
{simpArgs : Array (Lean.Syntax × Lean.Elab.Tactic.ElabSimpArgResult)} {ctx_1 : Lean.Meta.Simp.Context}
{simprocs_1 : Lean.Meta.Simp.SimprocsArray} {simpArgs_1 : Array (Lean.Syntax × Lean.Elab.Tactic.ElabSimpArgResult)},
{ ctx := ctx, simpr... | null | true |
Lean.Core.numBinders | Lean.Meta.ExprLens | {M : Type → Type} → [Monad M] → [Lean.MonadError M] → Lean.SubExpr.Pos → Lean.Expr → M ℕ | Returns the number of binders above a given subexpr position. | true |
MeromorphicAt.update | Mathlib.Analysis.Meromorphic.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : DecidableEq 𝕜] {f : 𝕜 → E} {z : 𝕜},
MeromorphicAt f z → ∀ (w : 𝕜) (e : E), MeromorphicAt (Function.update f w e) z | null | true |
_private.Mathlib.NumberTheory.LSeries.AbstractFuncEq.0.WeakFEPair.functional_equation_aux._simp_1_1 | Mathlib.NumberTheory.LSeries.AbstractFuncEq | ∀ {G : Type u_1} [inst : DivInvMonoid G] (a : G), a⁻¹ = 1 / a | null | false |
_private.Mathlib.Analysis.Real.OfDigits.0.Real.ofDigits_const_last_eq_one._simp_1_6 | Mathlib.Analysis.Real.OfDigits | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | null | false |
CategoryTheory.Limits.inl_inl_pushoutAssoc_hom_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Assoc | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X₁ X₂ X₃ Z₁ Z₂ : C} (g₁ : Z₁ ⟶ X₁) (g₂ : Z₁ ⟶ X₂)
(g₃ : Z₂ ⟶ X₂) (g₄ : Z₂ ⟶ X₃) [inst_1 : CategoryTheory.Limits.HasPushout g₁ g₂]
[inst_2 : CategoryTheory.Limits.HasPushout g₃ g₄]
[inst_3 :
CategoryTheory.Limits.HasPushout (CategoryTheory.CategoryStruc... | null | true |
_private.Lean.Meta.Tactic.Grind.Solve.0.Lean.Meta.Grind.solve._sparseCasesOn_1 | Lean.Meta.Tactic.Grind.Solve | {α : Type u} →
{motive : List α → Sort u_1} →
(t : List α) →
((head : α) → (tail : List α) → motive (head :: tail)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
closureCommutatorRepresentatives.eq_1 | Mathlib.GroupTheory.Commutator.Basic | ∀ (G : Type u_1) [inst : Group G],
closureCommutatorRepresentatives G =
Subgroup.closure (Prod.fst '' commutatorRepresentatives G ∪ Prod.snd '' commutatorRepresentatives G) | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.0._regBuiltin.UInt32.reduceSub.declare_182._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.2393314560._hygCtx._hyg.88 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | null | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftLeftConst._proof_10 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft | ∀ {w : ℕ}, 0 ≤ w | null | false |
IsAddIndecomposable.baseOf_subset_pos | Mathlib.Algebra.Group.Irreducible.Indecomposable | ∀ {ι : Type u_1} {M : Type u_2} {S : Type u_4} [inst : AddMonoid M] [inst_1 : LinearOrder S] [inst_2 : AddMonoid S]
(v : ι → M) (f : M →+ S), IsAddIndecomposable.baseOf v f ⊆ {i | 0 < f (v i)} | null | true |
NormedDivisionRing.nnratCast._inherited_default | Mathlib.Analysis.Normed.Field.Basic | {α : Type u_3} → (ℕ → α) → (α → α → α) → ℚ≥0 → α | null | false |
Filter.tendsto_ofReal_iff' | Mathlib.Analysis.Complex.Basic | ∀ {α : Type u_2} {𝕜 : Type u_3} [inst : RCLike 𝕜] {l : Filter α} {f : α → ℝ} {x : ℝ},
Filter.Tendsto (fun x => ↑(f x)) l (nhds ↑x) ↔ Filter.Tendsto f l (nhds x) | null | true |
Ordinal.IsFundamentalSeq | Mathlib.SetTheory.Ordinal.FundamentalSequence | {a o : Ordinal.{u_1}} → (↑(Set.Iio a) → ↑(Set.Iio o)) → Prop | A fundamental sequence for `o` is a strictly monotonic function `Iio o.cof.ord → Iio o` with
cofinal range. We provide `a = o.cof.ord` explicitly to avoid type rewrites. | true |
_private.Std.Http.Data.Body.Stream.0.Std.Http.Body.Channel.State.casesOn | Std.Http.Data.Body.Stream | {motive : Std.Http.Body.Channel.State✝ → Sort u} →
(t : Std.Http.Body.Channel.State✝) →
((pendingProducer : Option Std.Http.Body.Channel.Producer✝) →
(pendingConsumer : Option Std.Http.Body.Channel.Consumer✝) →
(interestWaiter : Option (Std.Async.Waiter Bool)) →
(closed : Bool) →
... | null | false |
OrderType.lift_type_eq_iff | Mathlib.Order.Types.Defs | ∀ {α β : Type u} [inst : LinearOrder α] [inst_1 : LinearOrder β],
OrderType.lift.{u_1, u} (OrderType.type α) = OrderType.lift.{u_1, u} (OrderType.type β) ↔ Nonempty (α ≃o β) | null | true |
Lean.Grind.AC.instBEqSeq.beq._sparseCasesOn_1 | Init.Grind.AC | {motive : Lean.Grind.AC.Seq → Sort u} →
(t : Lean.Grind.AC.Seq) →
((x : Lean.Grind.AC.Var) → motive (Lean.Grind.AC.Seq.var x)) → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
Lean.ToLevel.ctorIdx | Lean.ToLevel | Lean.ToLevel → ℕ | null | false |
TopPair.proj₁AdjDiag_unit_app | Mathlib.Topology.Category.TopPair | ∀ (X : TopPair),
TopPair.proj₁AdjDiag.unit.app X = TopPair.ofHom (CategoryTheory.CategoryStruct.id TopPair.fst) TopPair.map ⋯ | null | true |
Lean.Json.«json[_]» | Lean.Data.Json.Elab | Lean.ParserDescr | Json array syntax. | true |
ExceptT.bindCont.match_1 | Init.Control.Except | {ε α : Type u_1} →
(motive : Except ε α → Sort u_2) →
(x : Except ε α) → ((a : α) → motive (Except.ok a)) → ((e : ε) → motive (Except.error e)) → motive x | null | false |
AlgebraicGeometry.instSurjectiveOfGeometricallyIntegral | Mathlib.AlgebraicGeometry.Geometrically.Integral | ∀ {X S : AlgebraicGeometry.Scheme} (f : X ⟶ S) [AlgebraicGeometry.GeometricallyIntegral f],
AlgebraicGeometry.Surjective f | null | true |
CategoryTheory.FunctorToTypes.binaryProductEquiv._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.FunctorToTypes | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] (F G : CategoryTheory.Functor C (Type u_1)) (a : C)
(x : (F ⨯ G).obj a),
(fun z => CategoryTheory.FunctorToTypes.prodMk z.1 z.2)
((fun z =>
(((CategoryTheory.ConcreteCategory.hom ((CategoryTheory.FunctorToTypes.binaryProductIso F G).hom.... | null | false |
AddOpposite.opUniformEquivLeft._proof_1 | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ (G : Type u_1) [inst : AddGroup G] [inst_1 : TopologicalSpace G] [inst_2 : IsTopologicalAddGroup G],
UniformContinuous AddOpposite.opEquiv.toFun | null | false |
Lean.ModuleSetup.mk | Lean.Setup | Lean.Name →
Option Lean.PkgId →
Bool →
Option (Array Lean.Import) →
Lean.NameMap Lean.ImportArtifacts →
Array System.FilePath → Array Lean.Plugin → Lean.LeanOptions → Lean.ModuleSetup | null | true |
_private.Mathlib.Tactic.Setm.0.Mathlib.Tactic.SetM.SetMReplaceM | Mathlib.Tactic.Setm | Type → Type | null | true |
Mathlib.CrossRef.PiBaseTopic.topology | Mathlib.Tactic.CrossRefAttribute | Mathlib.CrossRef.PiBaseTopic | null | true |
CategoryTheory.Pseudofunctor.ObjectProperty.map_map_hom | Mathlib.CategoryTheory.Bicategory.Functor.Cat.ObjectProperty | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {F : CategoryTheory.Pseudofunctor B CategoryTheory.Cat}
(P : F.ObjectProperty) [inst_1 : P.IsClosedUnderMapObj] {X Y : B} (f : X ⟶ Y) {X_1 Y_1 : P.Obj X} (f_1 : X_1 ⟶ Y_1),
((P.map f).map f_1).hom = (F.map f).toFunctor.map f_1.hom | null | true |
ContinuousMap.comp.eq_1 | Mathlib.Condensed.TopComparison | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : TopologicalSpace γ] (f : C(β, γ)) (g : C(α, β)), f.comp g = { toFun := ⇑f ∘ ⇑g, continuous_toFun := ⋯ } | null | true |
CategoryTheory.ObjectProperty.isClosedUnderExtensions_unop_iff | Mathlib.CategoryTheory.ObjectProperty.Extensions | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(Q : CategoryTheory.ObjectProperty Cᵒᵖ), Q.unop.IsClosedUnderExtensions ↔ Q.IsClosedUnderExtensions | A property of objects `Q.unop` is closed under extensions iff `Q` is. | true |
Lean.Parser.parserAliases2infoRef | Lean.Parser.Extension | IO.Ref (Lean.NameMap Lean.Parser.ParserAliasInfo) | null | true |
FirstOrder.Language.Substructure.mem_comap | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type w} {N : Type u_1} [inst : L.Structure M] [inst_1 : L.Structure N]
{S : L.Substructure N} {f : L.Hom M N} {x : M}, x ∈ FirstOrder.Language.Substructure.comap f S ↔ f x ∈ S | null | true |
CategoryTheory.Presieve.BindStruct.hf | Mathlib.CategoryTheory.Sites.Sieves.Presieve | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} {S : CategoryTheory.Presieve X}
{R : ⦃Y : C⦄ → ⦃f : Y ⟶ X⦄ → S f → CategoryTheory.Presieve Y} {Z : C} {h : Z ⟶ X} (self : S.BindStruct R h), S self.f | null | true |
EuclideanGeometry.sin_oangle_right_mul_dist_of_oangle_eq_pi_div_two | Mathlib.Geometry.Euclidean.Angle.Oriented.RightAngle | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] [hd2 : Fact (Module.finrank ℝ V = 2)] [inst_4 : Module.Oriented ℝ V (Fin 2)]
{p₁ p₂ p₃ : P},
EuclideanGeometry.oangle p₁ p₂ p₃ = ↑(Real.pi / 2) → (EuclideanGeometr... | The sine of an angle in a right-angled triangle multiplied by the hypotenuse equals the
opposite side. | true |
Algebra.Generators.compLocalizationAwayAlgHom_relation_eq_zero | Mathlib.RingTheory.Extension.Cotangent.LocalizationAway | ∀ {R : Type u_1} {S : Type u_2} {T : Type u_3} {ι : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : CommRing T] [inst_4 : Algebra R T] [inst_5 : Algebra S T]
[inst_6 : IsScalarTower R S T] (g : S) [inst_7 : IsLocalization.Away g T] (P : Algebra.Generators R S ι),
(Algebra.Gene... | null | true |
SSet.coskAdj | Mathlib.AlgebraicTopology.SimplicialSet.Basic | (n : ℕ) → SSet.truncation n ⊣ SSet.Truncated.cosk n | The adjunction between n-truncation and the n-coskeleton. | true |
CochainComplex.mappingCone.d_fst_v' | Mathlib.Algebra.Homology.HomotopyCategory.MappingCone | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{F G : CochainComplex C ℤ} (φ : F ⟶ G) [inst_2 : HomologicalComplex.HasHomotopyCofiber φ] (i j : ℤ) (hij : i + 1 = j),
CategoryTheory.CategoryStruct.comp ((CochainComplex.mappingCone φ).d (i - 1) i)
((↑(Cochai... | null | true |
enorm_ne_zero | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_7} [inst : TopologicalSpace E] [inst_1 : ENormedAddMonoid E] {a : E}, ‖a‖ₑ ≠ 0 ↔ a ≠ 0 | null | true |
CategoryTheory.AddGrp.Hom.hom_add | Mathlib.CategoryTheory.Monoidal.Cartesian.Grp | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {G H : CategoryTheory.AddGrp C}
[inst_3 : CategoryTheory.IsCommAddMonObj H.X] (f g : G ⟶ H), (f + g).hom = f.hom + g.hom | null | true |
SSet.PtSimplex.MulStruct.mk._flat_ctor | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | {X : SSet} →
{n : ℕ} →
{x : X.obj (Opposite.op { len := 0 })} →
{f g fg : X.PtSimplex n x} →
{i : Fin n} →
(map : SSet.stdSimplex.obj { len := n + 1 } ⟶ X) →
autoParam (CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ i.castSucc.castSucc) map = g.map)
SSet.... | null | false |
_private.Lean.Meta.Sym.Simp.DiscrTree.0.Lean.Meta.Sym.pushArgsTodo._unsafe_rec | Lean.Meta.Sym.Simp.DiscrTree | Array Lean.Expr → Lean.Expr → Array Lean.Expr | null | false |
Std.Http.Protocol.H1.Reader.State.complete.sizeOf_spec | Std.Http.Protocol.H1.Reader | ∀ {dir : Std.Http.Protocol.H1.Direction}, sizeOf Std.Http.Protocol.H1.Reader.State.complete = 1 | null | true |
ENNReal.coe_iInf._simp_1 | Mathlib.Basic.ENNReal.Basic | ∀ {ι : Sort u_3} [Nonempty ι] (f : ι → NNReal), ⨅ a, ↑(f a) = ↑(iInf f) | null | false |
_private.Mathlib.Algebra.Ring.Divisibility.Lemmas.0.dvd_smul_of_dvd.match_1_1 | Mathlib.Algebra.Ring.Divisibility.Lemmas | ∀ {R : Type u_1} [inst : Semigroup R] {x y : R} (motive : x ∣ y → Prop) (h : x ∣ y),
(∀ (k : R) (hk : y = x * k), motive ⋯) → motive h | null | false |
_private.Mathlib.Analysis.PSeries.0.summable_schlomilch_iff_of_nonneg._simp_1_1 | Mathlib.Analysis.PSeries | ∀ {r₁ r₂ : NNReal}, (↑r₁ ≤ ↑r₂) = (r₁ ≤ r₂) | null | false |
KaehlerDifferential.quotKerTotalEquiv._proof_2 | Mathlib.RingTheory.Kaehler.Basic | ∀ (R : Type u_2) (S : Type u_1) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
Function.RightInverse (⇑(KaehlerDifferential.derivationQuotKerTotal R S).liftKaehlerDifferential)
((KaehlerDifferential.kerTotal R S).liftQ (Finsupp.linearCombination S ⇑(KaehlerDifferential.D R S)) ⋯).toFun | null | false |
Filter.lift_principal2 | Mathlib.Order.Filter.Lift | ∀ {α : Type u_1} {f : Filter α}, f.lift Filter.principal = f | null | true |
Commute.pow_pow_self | Mathlib.Algebra.Group.Commute.Defs | ∀ {M : Type u_2} [inst : Monoid M] (a : M) (m n : ℕ), Commute (a ^ m) (a ^ n) | null | true |
Lean.Lsp.Registration.noConfusionType | Lean.Data.Lsp.Client | Sort u → Lean.Lsp.Registration → Lean.Lsp.Registration → Sort u | null | false |
Int.natAbs_eq_iff | Init.Data.Int.Order | ∀ {a : ℤ} {n : ℕ}, a.natAbs = n ↔ a = ↑n ∨ a = -↑n | null | true |
MeasureTheory.L1.setToL1'.congr_simp | Mathlib.MeasureTheory.Integral.SetToL1.L1 | ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} (𝕜 : Type u_4) [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
[inst_4 : NormedRing 𝕜] [inst_5 : Module 𝕜 E] [inst_6 : Module 𝕜 F] [inst_7 : Is... | null | true |
MeasureTheory.lpTrimToLpMeasSubgroup._proof_1 | Mathlib.MeasureTheory.Function.ConditionalExpectation.AEMeasurable | ∀ {α : Type u_1} (F : Type u_2) (p : ENNReal) [inst : NormedAddCommGroup F] {m m0 : MeasurableSpace α}
(μ : MeasureTheory.Measure α) (hm : m ≤ m0) (f : ↥(MeasureTheory.Lp F p (μ.trim hm))), MeasureTheory.MemLp (↑↑f) p μ | null | false |
_private.Mathlib.Tactic.Ring.Basic.0.Mathlib.Tactic.Ring.ExBase.evalIntCast.match_1 | Mathlib.Tactic.Ring.Basic | {u : Lean.Level} →
{α : Q(Type u)} →
{a : Q(ℤ)} →
(rα : Q(CommRing «$α»)) →
(motive : ℕ × { e' // ↑«$a» =Q «$e'» } → Sort u_1) →
(x : ℕ × { e' // ↑«$a» =Q «$e'» }) →
((i : ℕ) → (b' : Q(«$α»)) → (property : ↑«$a» =Q «$b'») → motive (i, ⟨b', property⟩)) → motive x | null | false |
RootPairing.Base.cartanMatrixIn_mul_diagonal_eq | Mathlib.LinearAlgebra.RootSystem.CartanMatrix | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (S : Type u_5) [inst_5 : CommRing S]
[inst_6 : Algebra S R] {P : RootPairing ι R M N} [inst_7 : P.IsRootSystem] [inst_8 : P.IsValuedIn S]
... | null | true |
Set.Ioi_disjoint_Iio_iff._simp_2 | Mathlib.Order.Interval.Set.Disjoint | ∀ {α : Type v} [inst : Preorder α] {a b : α} [DenselyOrdered α], Disjoint (Set.Ioi a) (Set.Iio b) = ¬a < b | null | false |
Std.Iterators.Types.FilterMap.ctorIdx | Init.Data.Iterators.Combinators.Monadic.FilterMap | {α β γ : Type w} →
{m : Type w → Type w'} →
{n : Type w → Type w''} →
{lift : ⦃α : Type w⦄ → m α → n α} →
{f : β → Std.Iterators.PostconditionT n (Option γ)} → Std.Iterators.Types.FilterMap α m n lift f → ℕ | null | false |
Nat.log2_eq_succ_log2_shiftRight | Mathlib.Data.Nat.BinaryRec | ∀ {n : ℕ}, n >>> 1 ≠ 0 → n.log2 = (n >>> 1).log2.succ | null | true |
CategoryTheory.Abelian.Ext.covariant_sequence_exact₃' | Mathlib.Algebra.Homology.DerivedCategory.Ext.ExactSequences | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] (X : C) {S : CategoryTheory.ShortComplex C} (hS : S.ShortExact) (n₀ n₁ : ℕ)
(h : n₀ + 1 = n₁),
{ X₁ := ↧(CategoryTheory.Abelian.Ext X S.X₂ n₀), X₂ := ↧(CategoryTheory.Abelian.Ext X S.X₃ ... | Alternative formulation of `covariant_sequence_exact₃` | true |
Bimod.RightUnitorBimod.hom_right_act_hom' | Mathlib.CategoryTheory.Monoidal.Bimod | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Limits.HasCoequalizers C] {R S : CategoryTheory.Mon C} (P : Bimod R S)
[inst_3 :
∀ (X : C),
CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁}
(Catego... | null | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.getValueCast?_filter_not_contains_of_contains_right._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Sort u_1} {p : Prop} [inst : Decidable p] {x y : α}, ((if p then x else y) = x) = (¬p → y = x) | null | false |
Filter.instDistribNeg._proof_2 | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : HasDistribNeg α] (x x_1 : Filter α),
Filter.map₂ (fun x1 x2 => x1 * x2) x (Filter.map Neg.neg x_1) =
Filter.map Neg.neg (Filter.map₂ (fun x1 x2 => x1 * x2) x x_1) | null | false |
CategoryTheory.LaxBraidedFunctor.hom_ext_iff | Mathlib.CategoryTheory.Monoidal.Braided.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {D : Type u₂} [inst_3 : CategoryTheory.Category.{v₂, u₂} D]
[inst_4 : CategoryTheory.MonoidalCategory D] [inst_5 : CategoryTheory.BraidedCategory D]
{F G : CategoryT... | null | true |
CategoryTheory.ShortComplex.RightHomologyMapData.compatibilityOfZerosOfIsColimitCokernelCofork._proof_1 | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) (hf : S.f = 0) (hg : S.g = 0) (c : CategoryTheory.Limits.CokernelCofork S.f)
(hc : CategoryTheory.Limits.IsColimit c),
CategoryTheory.CategoryStruct.comp (Category... | null | false |
Std.Internal.IsStrictCut.toIsCut | Std.Data.Internal.Cut | ∀ {α : Type u} {cmp : α → α → Ordering} {cut : α → Ordering} [self : Std.Internal.IsStrictCut cmp cut],
Std.Internal.IsCut cmp cut | null | true |
WellFoundedGT.toIsSuccArchimedean | Mathlib.Order.SuccPred.Archimedean | ∀ {α : Type u_1} [inst : PartialOrder α] [h : WellFoundedGT α] [inst_1 : SuccOrder α], IsSuccArchimedean α | null | true |
AlgebraicGeometry.Scheme.IdealSheafData.support_bot | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme}, ⊥.support = ⊤ | null | true |
_private.Mathlib.CategoryTheory.Functor.KanExtension.Basic.0.CategoryTheory.Functor.isLeftKanExtension_iff_precomp_equivalence._simp_1_1 | Mathlib.CategoryTheory.Functor.KanExtension.Basic | ∀ {C : Type u_1} {H : Type u_3} {D : Type u_5} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_3, u_3} H] [inst_2 : CategoryTheory.Category.{v_5, u_5} D]
(F' : CategoryTheory.Functor D H) {L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor C H}
(α : F ⟶ L.comp F'),
F'... | null | false |
Std.ExtHashMap.getElem!_union_of_not_mem_left | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} [inst_2 : Inhabited β], k ∉ m₁ → (m₁ ∪ m₂)[k]! = m₂[k]! | null | true |
ContDiffMapSupportedIn.iteratedFDerivLM_eq_of_scalars | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ (𝕜 : Type u_1) {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace ℝ E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace ℝ F] [inst_5 : NormedSpace 𝕜 F]
[inst_6 : SMulCommClass ℝ 𝕜 F] {n k : ℕ∞} {K : TopologicalSpace.Compacts E} {i : ℕ} (... | null | true |
AddMonoidHom.le_map_tsub | Mathlib.Algebra.Order.Sub.Unbundled.Hom | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : AddCommMonoid α] [inst_2 : Sub α] [OrderedSub α]
[inst_4 : Preorder β] [inst_5 : AddZeroClass β] [inst_6 : Sub β] [OrderedSub β] (f : α →+ β),
Monotone ⇑f → ∀ (a b : α), f a - f b ≤ f (a - b) | null | true |
AddSubgroup.finiteIndex_iInf' | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : AddGroup G] {ι : Type u_3} {s : Finset ι} (f : ι → AddSubgroup G),
(∀ i ∈ s, (f i).FiniteIndex) → (⨅ i ∈ s, f i).FiniteIndex | null | true |
Finset.card_mul_singleton | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : Mul α] [IsRightCancelMul α] [inst_2 : DecidableEq α] (s : Finset α) (a : α),
(s * {a}).card = s.card | null | true |
Affine.Triangle.sbtw_touchpoint_empty | Mathlib.Geometry.Euclidean.Incenter.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] (t : Affine.Triangle ℝ P) {i₁ i₂ i₃ : Fin 3},
i₁ ≠ i₂ → i₁ ≠ i₃ → i₂ ≠ i₃ → Sbtw ℝ (t.points i₁) (Affine.Simplex.touchpoint t ∅ i₂) (t.points i₃) | null | true |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.Reify.0.Lean.Meta.Grind.Arith.Linear.assertNatCastNonneg | Lean.Meta.Tactic.Grind.Arith.Linear.Reify | Lean.Expr → Lean.Meta.Grind.Arith.Linear.LinearM Unit | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent.0.tendsto_euler_sin_prod'._simp_1_6 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
CategoryTheory.PreZeroHypercover.isLimitSigmaOfIsColimitEquiv._proof_7 | Mathlib.CategoryTheory.Sites.CoproductSheafCondition | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {S : C} (E : CategoryTheory.PreZeroHypercover S)
[inst_1 : E.HasPullbacks] {c : CategoryTheory.Limits.Cofan E.X} (hc : CategoryTheory.Limits.IsColimit c),
CategoryTheory.IsUniversalColimit c →
∀ [inst_2 : (E.sigmaOfIsColimit hc).HasPullbacks]
... | null | false |
_private.Mathlib.Algebra.Order.Star.Pi.0.Pi.instStarOrderedRing.match_6 | Mathlib.Algebra.Order.Star.Pi | ∀ {ι : Type u_1} {A : ι → Type u_2} [inst : (i : ι) → NonUnitalSemiring (A i)] [inst_1 : (i : ι) → StarRing (A i)]
(x : (i : ι) → A i) (motive : (∃ y, ∀ (x_1 : ι), star (y x_1) * y x_1 = x x_1) → Prop)
(x_1 : ∃ y, ∀ (x_1 : ι), star (y x_1) * y x_1 = x x_1),
(∀ (y : (i : ι) → A i) (hy : ∀ (x_2 : ι), star (y x_2) *... | null | false |
_private.Mathlib.LinearAlgebra.RootSystem.Finite.G2.0.RootPairing.zero_le_pairingIn_of_root_sub_mem._simp_1_1 | Mathlib.LinearAlgebra.RootSystem.Finite.G2 | ∀ {G : Type u_1} [inst : SubNegMonoid G] (a b : G), a + -b = a - b | null | false |
CommHopfAlgCat.instCategory | Mathlib.Algebra.Category.CommHopfAlgCat | {R : Type u} → [inst : CommRing R] → CategoryTheory.Category.{v, max (v + 1) u} (CommHopfAlgCat R) | null | true |
TendstoUniformlyOn.div | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : Group α] [IsUniformGroup α] {ι : Type u_3}
{l : Filter ι} {f f' : ι → β → α} {g g' : β → α} {s : Set β},
TendstoUniformlyOn f g l s → TendstoUniformlyOn f' g' l s → TendstoUniformlyOn (f / f') (g / g') l s | null | true |
AddGroupSeminorm.smul_sup | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {R : Type u_1} {E : Type u_3} [inst : AddGroup E] [inst_1 : SMul R ℝ] [inst_2 : SMul R NNReal]
[inst_3 : IsScalarTower R NNReal ℝ] (r : R) (p q : AddGroupSeminorm E), r • (p ⊔ q) = r • p ⊔ r • q | null | true |
PowerSeries.coe_rescaleAlgHom | Mathlib.RingTheory.PowerSeries.Substitution | ∀ {R : Type u_2} [inst : CommRing R] (r : R), ↑(PowerSeries.rescaleAlgHom r) = PowerSeries.rescale r | null | true |
Equiv.lattice._proof_2 | Mathlib.Order.Lattice | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : Lattice β] {x y : α}, e x < e y ↔ e x < e y | null | false |
_private.Mathlib.Data.List.Triplewise.0.List.triplewise_iff_getElem._simp_1_2 | Mathlib.Data.List.Triplewise | ∀ {α : Type u_1} {R : α → α → Prop} {l : List α},
List.Pairwise R l = ∀ (i j : ℕ) (_hi : i < l.length) (_hj : j < l.length), i < j → R l[i] l[j] | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.