name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.mkEMatchTheoremWithKind?._sparseCasesOn_1 | Lean.Meta.Tactic.Grind.EMatchTheorem | {motive : Lean.Meta.Grind.EMatchTheoremKind → Sort u} →
(t : Lean.Meta.Grind.EMatchTheoremKind) →
((gen : Bool) → motive (Lean.Meta.Grind.EMatchTheoremKind.eqLhs gen)) →
((gen : Bool) → motive (Lean.Meta.Grind.EMatchTheoremKind.eqRhs gen)) →
motive Lean.Meta.Grind.EMatchTheoremKind.eqBwd → (Nat.hasNotBit 11 t.ctorIdx → motive t) → motive t |
Array.getElem?_attach | Init.Data.Array.Attach | ∀ {α : Type u_1} {xs : Array α} {i : ℕ}, xs.attach[i]? = Option.pmap Subtype.mk xs[i]? ⋯ |
Rat.interior_compact_eq_empty | Mathlib.Topology.Instances.RatLemmas | ∀ {s : Set ℚ}, IsCompact s → interior s = ∅ |
Lean.Parser.OrElseOnAntiquotBehavior.merge.sizeOf_spec | Lean.Parser.Basic | sizeOf Lean.Parser.OrElseOnAntiquotBehavior.merge = 1 |
String.reduceLE._regBuiltin.String.reduceLE.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.String.974433241._hygCtx._hyg.22 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.String | IO Unit |
_private.Mathlib.Probability.Moments.SubGaussian.0.ProbabilityTheory.HasSubgaussianMGF_iff_kernel.match_1_3 | Mathlib.Probability.Moments.SubGaussian | ∀ {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {X : Ω → ℝ} {c : NNReal}
(motive :
ProbabilityTheory.Kernel.HasSubgaussianMGF X c (ProbabilityTheory.Kernel.const Unit μ)
(MeasureTheory.Measure.dirac ()) →
Prop)
(x :
ProbabilityTheory.Kernel.HasSubgaussianMGF X c (ProbabilityTheory.Kernel.const Unit μ)
(MeasureTheory.Measure.dirac ())),
(∀
(h1 :
∀ (t : ℝ),
MeasureTheory.Integrable (fun ω => Real.exp (t * X ω))
((MeasureTheory.Measure.dirac ()).bind ⇑(ProbabilityTheory.Kernel.const Unit μ)))
(h2 :
∀ᵐ (ω' : Unit) ∂MeasureTheory.Measure.dirac (),
∀ (t : ℝ),
ProbabilityTheory.mgf X ((ProbabilityTheory.Kernel.const Unit μ) ω') t ≤ Real.exp (↑c * t ^ 2 / 2)),
motive ⋯) →
motive x |
NormedAddGroupHom._sizeOf_1 | Mathlib.Analysis.Normed.Group.Hom | {V : Type u_1} →
{W : Type u_2} →
{inst : SeminormedAddCommGroup V} →
{inst_1 : SeminormedAddCommGroup W} → [SizeOf V] → [SizeOf W] → NormedAddGroupHom V W → ℕ |
MulArchimedeanOrder.val.eq_1 | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1}, MulArchimedeanOrder.val = Equiv.refl (MulArchimedeanOrder M) |
MeasurableSMul.rec | Mathlib.MeasureTheory.Group.Arithmetic | {M : Type u_2} →
{α : Type u_3} →
[inst : SMul M α] →
[inst_1 : MeasurableSpace M] →
[inst_2 : MeasurableSpace α] →
{motive : MeasurableSMul M α → Sort u} →
([toMeasurableConstSMul : MeasurableConstSMul M α] →
(measurable_smul_const : ∀ (x : α), Measurable fun x_1 => x_1 • x) → motive ⋯) →
(t : MeasurableSMul M α) → motive t |
Lean.Meta.Grind.AC.DiseqCnstrProof.simp_middle | Lean.Meta.Tactic.Grind.AC.Types | Bool →
Lean.Grind.AC.Seq →
Lean.Grind.AC.Seq → Lean.Meta.Grind.AC.EqCnstr → Lean.Meta.Grind.AC.DiseqCnstr → Lean.Meta.Grind.AC.DiseqCnstrProof |
Std.ExtHashMap.contains_of_contains_filterMap | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {f : α → β → Option γ} {k : α},
(Std.ExtHashMap.filterMap f m).contains k = true → m.contains k = true |
Complex.UnitDisc.mk_neg | Mathlib.Analysis.Complex.UnitDisc.Basic | ∀ (z : ℂ) (hz : ‖-z‖ < 1), Complex.UnitDisc.mk (-z) hz = -Complex.UnitDisc.mk z ⋯ |
ValuativeRel.trivialRel._proof_5 | Mathlib.RingTheory.Valuation.ValuativeRel.Trivial | ∀ {R : Type} [inst : CommRing R] [inst_1 : DecidableEq R] [IsDomain R] {x y z : R},
(¬if 0 = 0 then z = 0 else True) → (if y * z = 0 then x * z = 0 else True) → if y = 0 then x = 0 else True |
PowerBasis.liftEquiv._proof_6 | Mathlib.RingTheory.PowerBasis | ∀ {S : Type u_3} [inst : Ring S] {A : Type u_2} [inst_1 : CommRing A] [inst_2 : Algebra A S] {S' : Type u_1}
[inst_3 : Ring S'] [inst_4 : Algebra A S'] (pb : PowerBasis A S)
(y : { y // (Polynomial.aeval y) (minpoly A pb.gen) = 0 }), ⟨(pb.lift ↑y ⋯) pb.gen, ⋯⟩ = y |
Mathlib.Tactic.superscriptTerm | Mathlib.Util.Superscript | Lean.Parser.Parser |
CategoryTheory.effectiveEpiFamilyStructOfComp._proof_4 | Mathlib.CategoryTheory.EffectiveEpi.Comp | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {I : Type u_3} {Z Y : I → C} {X : C}
(g : (i : I) → Z i ⟶ Y i) (f : (i : I) → Y i ⟶ X) {W : C} (φ : (a : I) → Y a ⟶ W),
(∀ {Z : C} (a₁ a₂ : I) (g₁ : Z ⟶ Y a₁) (g₂ : Z ⟶ Y a₂),
CategoryTheory.CategoryStruct.comp g₁ (f a₁) = CategoryTheory.CategoryStruct.comp g₂ (f a₂) →
CategoryTheory.CategoryStruct.comp g₁ (φ a₁) = CategoryTheory.CategoryStruct.comp g₂ (φ a₂)) →
∀ {Z_1 : C} (i₁ i₂ : I) (g₁ : Z_1 ⟶ Z i₁) (g₂ : Z_1 ⟶ Z i₂),
CategoryTheory.CategoryStruct.comp g₁ (CategoryTheory.CategoryStruct.comp (g i₁) (f i₁)) =
CategoryTheory.CategoryStruct.comp g₂ (CategoryTheory.CategoryStruct.comp (g i₂) (f i₂)) →
CategoryTheory.CategoryStruct.comp g₁ (CategoryTheory.CategoryStruct.comp (g i₁) (φ i₁)) =
CategoryTheory.CategoryStruct.comp g₂ (CategoryTheory.CategoryStruct.comp (g i₂) (φ i₂)) |
_private.Mathlib.Algebra.Order.Archimedean.Basic.0.existsUnique_div_zpow_mem_Ico._simp_1_1 | Mathlib.Algebra.Order.Archimedean.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, (x ∈ Set.Ico a b) = (a ≤ x ∧ x < b) |
AlternatingMap.instFunLike._proof_1 | Mathlib.LinearAlgebra.Alternating.Basic | ∀ {R : Type u_4} [inst : Semiring R] {M : Type u_1} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_2}
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] {ι : Type u_3} (f g : M [⋀^ι]→ₗ[R] N),
(fun f => (↑f).toFun) f = (fun f => (↑f).toFun) g → f = g |
AlgebraicGeometry.Scheme.Cover.map_prop | Mathlib.AlgebraicGeometry.Cover.MorphismProperty | ∀ {X : AlgebraicGeometry.Scheme} {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme}
(𝒰 : AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) X) (i : 𝒰.I₀), P (𝒰.f i) |
Condensed.StoneanCompHaus.equivalence._proof_5 | Mathlib.Condensed.Equivalence | CategoryTheory.FinitaryPreExtensive Stonean |
_private.Mathlib.Tactic.FunProp.Mor.0.Mathlib.Meta.FunProp.Mor.whnfPred.match_3 | Mathlib.Tactic.FunProp.Mor | (motive : Option Lean.Expr → Sort u_1) →
(__do_lift : Option Lean.Expr) → ((e : Lean.Expr) → motive (some e)) → (Unit → motive none) → motive __do_lift |
_private.Mathlib.Analysis.Normed.Operator.BoundedLinearMaps.0.IsBoundedLinearMap.isBigO_id.match_1_1 | Mathlib.Analysis.Normed.Operator.BoundedLinearMaps | ∀ {E : Type u_2} {F : Type u_1} [inst : SeminormedAddCommGroup E] [inst_1 : SeminormedAddCommGroup F] {f : E → F}
(motive : (∃ M, 0 < M ∧ ∀ (x : E), ‖f x‖ ≤ M * ‖x‖) → Prop) (x : ∃ M, 0 < M ∧ ∀ (x : E), ‖f x‖ ≤ M * ‖x‖),
(∀ (w : ℝ) (left : 0 < w) (hM : ∀ (x : E), ‖f x‖ ≤ w * ‖x‖), motive ⋯) → motive x |
CategoryTheory.TransfiniteCompositionOfShape.incl | Mathlib.CategoryTheory.Limits.Shapes.Preorder.TransfiniteCompositionOfShape | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type w} →
[inst_1 : LinearOrder J] →
[inst_2 : OrderBot J] →
{X Y : C} →
{f : X ⟶ Y} →
[inst_3 : SuccOrder J] →
[inst_4 : WellFoundedLT J] →
(self : CategoryTheory.TransfiniteCompositionOfShape J f) →
self.F ⟶ (CategoryTheory.Functor.const J).obj Y |
_private.Mathlib.Topology.Algebra.InfiniteSum.ConditionalInt.0.HasProd.hasProd_symmetricIco_of_hasProd_symmetricIcc._proof_1_3 | Mathlib.Topology.Algebra.InfiniteSum.ConditionalInt | ∀ (N : ℕ), -↑N ≤ ↑N |
_private.Mathlib.GroupTheory.Perm.Cycle.Basic.0.Equiv.Perm.IsCycleOn.pow_apply_eq_pow_apply._simp_1_1 | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Sort u_1} {β : Sort u_2} (e : α ≃ β) {x : β} {y : α}, (y = e.symm x) = (e y = x) |
Lean.Order.coind_monotone_forall | Init.Internal.Order.Basic | ∀ {α : Sort u_1} [inst : Lean.Order.PartialOrder α] {β : Sort u_2} (f : α → β → Lean.Order.ReverseImplicationOrder),
Lean.Order.monotone f → Lean.Order.monotone fun x => ∀ (y : β), f x y |
CategoryTheory.GlueData'.t''._proof_7 | Mathlib.CategoryTheory.GlueData | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (D : CategoryTheory.GlueData' C) (i j k : D.J)
(hij : ¬i = j) (hjk : ¬j = k), CategoryTheory.Limits.HasPullback (D.f j k hjk) (D.f j i ⋯) |
_private.Init.Grind.ToInt.0.Lean.Grind.instBEqIntInterval.beq.eq_def | Init.Grind.ToInt | ∀ (x x_1 : Lean.Grind.IntInterval),
Lean.Grind.instBEqIntInterval.beq x x_1 =
match x, x_1 with
| Lean.Grind.IntInterval.co a a_1, Lean.Grind.IntInterval.co b b_1 => a == b && a_1 == b_1
| Lean.Grind.IntInterval.ci a, Lean.Grind.IntInterval.ci b => a == b
| Lean.Grind.IntInterval.io a, Lean.Grind.IntInterval.io b => a == b
| Lean.Grind.IntInterval.ii, Lean.Grind.IntInterval.ii => true
| x, x_2 => false |
Lean.ParserDescr.unicodeSymbol | Init.Prelude | String → String → Bool → Lean.ParserDescr |
_private.Lean.Meta.Tactic.Grind.Order.Assert.0.Lean.Meta.Grind.Order.propagatePending.match_1 | Lean.Meta.Tactic.Grind.Order.Assert | (motive : Lean.Meta.Grind.Order.ToPropagate → Sort u_1) →
(p : Lean.Meta.Grind.Order.ToPropagate) →
((c : Lean.Meta.Grind.Order.Cnstr Lean.Meta.Grind.Order.NodeId) →
(e : Lean.Expr) →
(u v : Lean.Meta.Grind.Order.NodeId) →
(k k' : Lean.Meta.Grind.Order.Weight) → motive (Lean.Meta.Grind.Order.ToPropagate.eqTrue c e u v k k')) →
((c : Lean.Meta.Grind.Order.Cnstr Lean.Meta.Grind.Order.NodeId) →
(e : Lean.Expr) →
(u v : Lean.Meta.Grind.Order.NodeId) →
(k k' : Lean.Meta.Grind.Order.Weight) → motive (Lean.Meta.Grind.Order.ToPropagate.eqFalse c e u v k k')) →
((u v : Lean.Meta.Grind.Order.NodeId) → motive (Lean.Meta.Grind.Order.ToPropagate.eq u v)) → motive p |
Module.Dual.baseChange._proof_2 | Mathlib.LinearAlgebra.Dual.BaseChange | ∀ {R : Type u_1} [inst : CommSemiring R] (A : Type u_2) [inst_1 : CommSemiring A] [inst_2 : Algebra R A],
SMulCommClass R A A |
Cardinal.partialOrder._proof_2 | Mathlib.SetTheory.Cardinal.Order | ∀ (a b c : Cardinal.{u_1}), a ≤ b → b ≤ c → a ≤ c |
UpperHalfPlane.petersson_slash_SL | Mathlib.NumberTheory.ModularForms.Petersson | ∀ (k : ℤ) (f f' : UpperHalfPlane → ℂ) (g : Matrix.SpecialLinearGroup (Fin 2) ℤ) (τ : UpperHalfPlane),
UpperHalfPlane.petersson k (SlashAction.map k g f) (SlashAction.map k g f') τ =
UpperHalfPlane.petersson k f f' (g • τ) |
ContinuousMapZero.instNonUnitalCommSemiring._proof_10 | Mathlib.Topology.ContinuousMap.ContinuousMapZero | ∀ {X : Type u_1} {R : Type u_2} [inst : Zero X] [inst_1 : TopologicalSpace X] [inst_2 : TopologicalSpace R]
[inst_3 : CommSemiring R] [inst_4 : IsTopologicalSemiring R] (a : ContinuousMapZero X R), 0 * a = 0 |
CategoryTheory.CostructuredArrow.map_mk | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{T T' : D} {Y : C} {S : CategoryTheory.Functor C D} {f : S.obj Y ⟶ T} (g : T ⟶ T'),
(CategoryTheory.CostructuredArrow.map g).obj (CategoryTheory.CostructuredArrow.mk f) =
CategoryTheory.CostructuredArrow.mk (CategoryTheory.CategoryStruct.comp f g) |
_private.Lean.Compiler.LCNF.Simp.FunDeclInfo.0.Lean.Compiler.LCNF.Simp.FunDeclInfoMap.update.addLetValueOccs | Lean.Compiler.LCNF.Simp.FunDeclInfo | Lean.Compiler.LCNF.LetValue Lean.Compiler.LCNF.Purity.pure →
StateRefT' IO.RealWorld Lean.Compiler.LCNF.Simp.FunDeclInfoMap Lean.Compiler.LCNF.CompilerM Unit |
DilationEquiv.recOn | Mathlib.Topology.MetricSpace.DilationEquiv | {X : Type u_1} →
{Y : Type u_2} →
[inst : PseudoEMetricSpace X] →
[inst_1 : PseudoEMetricSpace Y] →
{motive : X ≃ᵈ Y → Sort u} →
(t : X ≃ᵈ Y) →
((toEquiv : X ≃ Y) →
(edist_eq' : ∃ r, r ≠ 0 ∧ ∀ (x y : X), edist (toEquiv.toFun x) (toEquiv.toFun y) = ↑r * edist x y) →
motive { toEquiv := toEquiv, edist_eq' := edist_eq' }) →
motive t |
Function.Injective.addMonoid._proof_3 | Mathlib.Algebra.Group.InjSurj | ∀ {M₁ : Type u_1} {M₂ : Type u_2} [inst : Add M₁] [inst_1 : Zero M₁] [inst_2 : SMul ℕ M₁] [inst_3 : AddMonoid M₂]
(f : M₁ → M₂) (hf : Function.Injective f) (zero : f 0 = 0) (add : ∀ (x y : M₁), f (x + y) = f x + f y),
(∀ (x : M₁) (n : ℕ), f (n • x) = n • f x) → ∀ (x : M₁), 0 • x = 0 |
CondensedSet.topCatAdjunctionUnit | Mathlib.Condensed.TopCatAdjunction | (X : CondensedSet) → X ⟶ X.toTopCat.toCondensedSet |
AlgebraicTopology.DoldKan.QInfty_comp_PInfty_assoc | Mathlib.AlgebraicTopology.DoldKan.PInfty | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{X : CategoryTheory.SimplicialObject C} {Z : ChainComplex C ℕ}
(h : AlgebraicTopology.AlternatingFaceMapComplex.obj X ⟶ Z),
CategoryTheory.CategoryStruct.comp AlgebraicTopology.DoldKan.QInfty
(CategoryTheory.CategoryStruct.comp AlgebraicTopology.DoldKan.PInfty h) =
CategoryTheory.CategoryStruct.comp 0 h |
_private.Lean.Elab.BuiltinNotation.0.Lean.Elab.Term.isSubstCandidate | Lean.Elab.BuiltinNotation | Lean.Expr → Lean.Expr → Lean.MetaM Bool |
Order.isSuccPrelimit_toDual_iff | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {a : α} [inst : LT α], Order.IsSuccPrelimit (OrderDual.toDual a) ↔ Order.IsPredPrelimit a |
OpenAddSubgroup.toAddSubgroup_sup._simp_1 | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [inst_2 : ContinuousAdd G] (U V : OpenAddSubgroup G),
↑U ⊔ ↑V = ↑(U ⊔ V) |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr.0.Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr.assertCore | Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr | Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr → Lean.Meta.Grind.GoalM Unit |
FirstOrder.Field.FieldAxiom.toProp.eq_7 | Mathlib.ModelTheory.Algebra.Field.Basic | ∀ (K : Type u_2) [inst : Add K] [inst_1 : Mul K] [inst_2 : Neg K] [inst_3 : Zero K] [inst_4 : One K],
FirstOrder.Field.FieldAxiom.toProp K FirstOrder.Field.FieldAxiom.existsInv = ∀ (x : K), x ≠ 0 → ∃ y, x * y = 1 |
CategoryTheory.Limits.PreservesFiniteProducts.casesOn | Mathlib.CategoryTheory.Limits.Preserves.Finite | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
{motive : CategoryTheory.Limits.PreservesFiniteProducts F → Sort u} →
(t : CategoryTheory.Limits.PreservesFiniteProducts F) →
((preserves :
∀ (n : ℕ), CategoryTheory.Limits.PreservesLimitsOfShape (CategoryTheory.Discrete (Fin n)) F) →
motive ⋯) →
motive t |
CommRingCat.Colimits.ColimitType.AddGroupWithOne._proof_3 | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CommRingCat) (n : ℕ),
(↑n).castDef = ↑n |
ContinuousMap.instNormedAlgebra._proof_2 | Mathlib.Topology.ContinuousMap.Compact | ∀ {α : Type u_1} [inst : TopologicalSpace α] {𝕜 : Type u_3} {γ : Type u_2} [inst_1 : NormedField 𝕜]
[inst_2 : SeminormedRing γ] [inst_3 : NormedAlgebra 𝕜 γ] (r : 𝕜) (x : C(α, γ)),
Algebra.algebraMap r * x = x * Algebra.algebraMap r |
smoothPresheafRing | Mathlib.Geometry.Manifold.Sheaf.Smooth | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{EM : Type u_2} →
[inst_1 : NormedAddCommGroup EM] →
[inst_2 : NormedSpace 𝕜 EM] →
{HM : Type u_3} →
[inst_3 : TopologicalSpace HM] →
ModelWithCorners 𝕜 EM HM →
{E : Type u_4} →
[inst_4 : NormedAddCommGroup E] →
[inst_5 : NormedSpace 𝕜 E] →
{H : Type u_5} →
[inst_6 : TopologicalSpace H] →
(I : ModelWithCorners 𝕜 E H) →
(M : Type u) →
[inst_7 : TopologicalSpace M] →
[ChartedSpace HM M] →
(R : Type u) →
[inst_9 : TopologicalSpace R] →
[inst_10 : ChartedSpace H R] →
[inst_11 : Ring R] →
[ContMDiffRing I (↑⊤) R] → TopCat.Presheaf RingCat (TopCat.of M) |
ContinuousMap.instNonUnitalSemiringOfIsTopologicalSemiring._proof_1 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {β : Type u_1} [inst : TopologicalSpace β] [inst_1 : NonUnitalSemiring β] [IsTopologicalSemiring β], ContinuousAdd β |
Matrix.l2_opNNNorm_conjTranspose | Mathlib.Analysis.CStarAlgebra.Matrix | ∀ {𝕜 : Type u_1} {m : Type u_2} {n : Type u_3} [inst : RCLike 𝕜] [inst_1 : Fintype m] [inst_2 : Fintype n]
[inst_3 : DecidableEq n] [inst_4 : DecidableEq m] (A : Matrix m n 𝕜), ‖A.conjTranspose‖₊ = ‖A‖₊ |
LT.lt.pos | Mathlib.Algebra.Order.Monoid.Canonical.Defs | ∀ {α : Type u} [inst : AddZeroClass α] [inst_1 : Preorder α] [CanonicallyOrderedAdd α] {a b : α}, a < b → 0 < b |
_private.Lean.Elab.PreDefinition.TerminationMeasure.0.Lean.Elab.TerminationMeasure.delab.go.match_1.splitter | Lean.Elab.PreDefinition.TerminationMeasure | (motive : ℕ → Lean.TSyntaxArray `ident → Sort u_1) →
(x : ℕ) →
(x_1 : Lean.TSyntaxArray `ident) →
((vars : Lean.TSyntaxArray `ident) → motive 0 vars) →
((i : ℕ) → (vars : Lean.TSyntaxArray `ident) → motive i.succ vars) → motive x x_1 |
LieAlgebra.exists_isRegular | Mathlib.Algebra.Lie.Rank | ∀ (R : Type u_1) (L : Type u_3) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : Module.Finite R L] [inst_4 : Module.Free R L] [IsDomain R] [Infinite R], ∃ x, LieAlgebra.IsRegular R x |
CategoryTheory.MorphismProperty.LeftFraction.f | Mathlib.CategoryTheory.Localization.CalculusOfFractions | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{W : CategoryTheory.MorphismProperty C} → {X Y : C} → (self : W.LeftFraction X Y) → X ⟶ self.Y' |
_private.Mathlib.Combinatorics.SimpleGraph.Matching.0.SimpleGraph.Subgraph.isMatching_iff_forall_degree._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Matching | ∀ {V : Type u} {G : SimpleGraph V} {G' : G.Subgraph} {v : V} [inst : Fintype ↑(G'.neighborSet v)],
(G'.degree v = 1) = ∃! w, G'.Adj v w |
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.enumsPass.postprocess | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums | Lean.MVarId →
StateRefT' IO.RealWorld Lean.Elab.Tactic.BVDecide.Frontend.Normalize.PostProcessState✝ Lean.MetaM Lean.MVarId |
NFA.accepts_iff_exists_path | Mathlib.Computability.NFA | ∀ {α : Type u} {σ : Type v} {M : NFA α σ} {x : List α},
x ∈ M.accepts ↔ ∃ s ∈ M.start, ∃ t ∈ M.accept, Nonempty (M.Path s t x) |
Multiset.mem_sym2_iff | Mathlib.Data.Multiset.Sym | ∀ {α : Type u_1} {m : Multiset α} {z : Sym2 α}, z ∈ m.sym2 ↔ ∀ y ∈ z, y ∈ m |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.Assoc.0.CategoryTheory.Limits.termG₃ | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Assoc | Lean.ParserDescr |
MeasureTheory.probReal_add_probReal_compl | Mathlib.MeasureTheory.Measure.Typeclasses.Probability | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α}
[MeasureTheory.IsProbabilityMeasure μ], MeasurableSet s → μ.real s + μ.real sᶜ = 1 |
Function.mem_support | Mathlib.Algebra.Notation.Support | ∀ {ι : Type u_1} {M : Type u_3} [inst : Zero M] {f : ι → M} {x : ι}, x ∈ Function.support f ↔ f x ≠ 0 |
_private.Init.Meta.Defs.0.Lean.Syntax.decodeNameLit.match_1 | Init.Meta.Defs | (motive : Lean.Name → Sort u_1) →
(x : Lean.Name) → (Unit → motive Lean.Name.anonymous) → ((name : Lean.Name) → motive name) → motive x |
_private.Lean.Meta.ExprLens.0.Lean.Meta.foldAncestorsAux._unsafe_rec | Lean.Meta.ExprLens | {M : Type → Type} →
[Monad M] →
[MonadLiftT Lean.MetaM M] →
[MonadControlT Lean.MetaM M] →
[Lean.MonadError M] →
{α : Type} → (Array Lean.Expr → Lean.Expr → ℕ → α → M α) → α → List ℕ → Array Lean.Expr → Lean.Expr → M α |
CategoryTheory.Limits.ConeMorphism.ext | 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 c' : CategoryTheory.Limits.Cone F} (f g : c ⟶ c'), f.hom = g.hom → f = g |
LinearMap.compAlternatingMap_smul | Mathlib.LinearAlgebra.Alternating.Basic | ∀ {R : Type u_1} [inst : Semiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_3}
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] {ι : Type u_7} {S : Type u_10} {N₂ : Type u_11}
[inst_5 : AddCommMonoid N₂] [inst_6 : Module R N₂] [inst_7 : Monoid S] [inst_8 : DistribMulAction S N]
[inst_9 : DistribMulAction S N₂] [inst_10 : SMulCommClass R S N] [inst_11 : SMulCommClass R S N₂]
[LinearMap.CompatibleSMul N N₂ S R] (g : N →ₗ[R] N₂) (s : S) (f : M [⋀^ι]→ₗ[R] N),
g.compAlternatingMap (s • f) = s • g.compAlternatingMap f |
Nat.getElem?_toArray_roc | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n i : ℕ}, (m<...=n).toArray[i]? = if i < n - m then some (m + 1 + i) else none |
Module.Basis.isUnitSMul | Mathlib.LinearAlgebra.Basis.SMul | {ι : Type u_1} →
{R : Type u_2} →
{M : Type u_4} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] → Module.Basis ι R M → {w : ι → R} → (∀ (i : ι), IsUnit (w i)) → Module.Basis ι R M |
squarefree_iff_irreducible_sq_not_dvd_of_ne_zero | Mathlib.Algebra.Squarefree.Basic | ∀ {R : Type u_1} [inst : CommMonoidWithZero R] [WfDvdMonoid R] {r : R},
r ≠ 0 → (Squarefree r ↔ ∀ (x : R), Irreducible x → ¬x * x ∣ r) |
DiffContOnCl.circleAverage | Mathlib.Analysis.Complex.MeanValue | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] [CompleteSpace E] {f : ℂ → E} {R : ℝ} {c : ℂ},
DiffContOnCl ℂ f (Metric.ball c |R|) → Real.circleAverage f c R = f c |
Int.negSucc_shiftRight | Init.Data.Int.Bitwise.Lemmas | ∀ (m n : ℕ), Int.negSucc m >>> n = Int.negSucc (m >>> n) |
Aesop.traceSimpTheoremTreeContents | Aesop.Tracing | Lean.Meta.SimpTheoremTree → Aesop.TraceOption → Lean.CoreM Unit |
OnePoint.not_specializes_infty_coe | Mathlib.Topology.Compactification.OnePoint.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x : X}, ¬OnePoint.infty ⤳ ↑x |
IsFreeGroupoid.SpanningTree.treeHom.eq_1 | Mathlib.GroupTheory.FreeGroup.NielsenSchreier | ∀ {G : Type u} [inst : CategoryTheory.Groupoid G] [inst_1 : IsFreeGroupoid G]
(T : WideSubquiver (Quiver.Symmetrify (IsFreeGroupoid.Generators G)))
[inst_2 : Quiver.Arborescence (WideSubquiver.toType (Quiver.Symmetrify (IsFreeGroupoid.Generators G)) T)] (a : G),
IsFreeGroupoid.SpanningTree.treeHom T a = IsFreeGroupoid.SpanningTree.homOfPath T default |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.transformObjComp_inv_app_fst_app | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B} {A₁ : Type u₄} {B₁ : Type u₅} {C₁ : Type u₆}
[inst_3 : CategoryTheory.Category.{v₄, u₄} A₁] [inst_4 : CategoryTheory.Category.{v₅, u₅} B₁]
[inst_5 : CategoryTheory.Category.{v₆, u₆} C₁] {F₁ : CategoryTheory.Functor A₁ B₁} {G₁ : CategoryTheory.Functor C₁ B₁}
{A₂ : Type u₇} {B₂ : Type u₈} {C₂ : Type u₉} [inst_6 : CategoryTheory.Category.{v₇, u₇} A₂]
[inst_7 : CategoryTheory.Category.{v₈, u₈} B₂] [inst_8 : CategoryTheory.Category.{v₉, u₉} C₂]
{F₂ : CategoryTheory.Functor A₂ B₂} {G₂ : CategoryTheory.Functor C₂ B₂} (X : Type u₁₀)
[inst_9 : CategoryTheory.Category.{v₁₀, u₁₀} X] (ψ : CategoryTheory.Limits.CatCospanTransform F G F₁ G₁)
(ψ' : CategoryTheory.Limits.CatCospanTransform F₁ G₁ F₂ G₂)
(X_1 : CategoryTheory.Limits.CategoricalPullback.CatCommSqOver F G X) (x : X),
((CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.transformObjComp X ψ ψ').inv.app X_1).fst.app x =
CategoryTheory.CategoryStruct.id (ψ'.left.obj (ψ.left.obj (X_1.fst.obj x))) |
HopfAlgCat.tensorUnit_carrier | Mathlib.Algebra.Category.HopfAlgCat.Monoidal | ∀ (R : Type u) [inst : CommRing R], (CategoryTheory.MonoidalCategoryStruct.tensorUnit (HopfAlgCat R)).carrier = R |
LawfulFix.mk._flat_ctor | Mathlib.Control.LawfulFix | {α : Type u_3} →
[inst : OmegaCompletePartialOrder α] →
(fix : (α → α) → α) →
(∀ {f : α → α}, OmegaCompletePartialOrder.ωScottContinuous f → fix f = f (fix f)) → LawfulFix α |
CategoryTheory.Limits.coequalizer.isoTargetOfSelf_inv | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y),
(CategoryTheory.Limits.coequalizer.isoTargetOfSelf f).inv = CategoryTheory.Limits.coequalizer.π f f |
Real.le_sqrt' | Mathlib.Data.Real.Sqrt | ∀ {x y : ℝ}, 0 < x → (x ≤ √y ↔ x ^ 2 ≤ y) |
Set.disjoint_of_subset_iff_left_eq_empty | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} {s t : Set α}, s ⊆ t → (Disjoint s t ↔ s = ∅) |
MeasureTheory.Lp.instLattice | Mathlib.MeasureTheory.Function.LpOrder | {α : Type u_1} →
{E : Type u_2} →
{m : MeasurableSpace α} →
{μ : MeasureTheory.Measure α} →
{p : ENNReal} →
[inst : NormedAddCommGroup E] →
[inst_1 : Lattice E] → [HasSolidNorm E] → [IsOrderedAddMonoid E] → Lattice ↥(MeasureTheory.Lp E p μ) |
CauSeq.Completion.Cauchy.field._proof_6 | Mathlib.Algebra.Order.CauSeq.Completion | ∀ {α : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] {β : Type u_1}
[inst_3 : Field β] {abv : β → α} [inst_4 : IsAbsoluteValue abv], Nontrivial (CauSeq.Completion.Cauchy abv) |
groupCohomology.functor | Mathlib.RepresentationTheory.Homological.GroupCohomology.Functoriality | (k G : Type u) → [inst : CommRing k] → [inst_1 : Group G] → ℕ → CategoryTheory.Functor (Rep k G) (ModuleCat k) |
MeasureTheory.StronglyMeasurable.div₀ | Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic | ∀ {α : Type u_1} {β : Type u_2} {f g : α → β} {mα : MeasurableSpace α} [inst : TopologicalSpace β]
[inst_1 : GroupWithZero β] [ContinuousMul β] [ContinuousInv₀ β],
MeasureTheory.StronglyMeasurable f →
MeasureTheory.StronglyMeasurable g → (∀ (x : α), g x ≠ 0) → MeasureTheory.StronglyMeasurable (f / g) |
Equiv.apply_eq_iff_eq_symm_apply | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u} {β : Sort v} {x : α} {y : β} (f : α ≃ β), f x = y ↔ x = f.symm y |
contractRight_apply | Mathlib.LinearAlgebra.Contraction | ∀ {R : Type u_2} {M : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(f : Module.Dual R M) (m : M), (contractRight R M) (m ⊗ₜ[R] f) = f m |
WithZero.instDivisionMonoid.match_1 | Mathlib.Algebra.GroupWithZero.WithZero | ∀ {α : Type u_1} (motive : WithZero α → WithZero α → Prop) (x x_1 : WithZero α),
(∀ (a : Unit), motive none none) →
(∀ (val : α), motive none (some val)) →
(∀ (val : α), motive (some val) none) → (∀ (val val_1 : α), motive (some val) (some val_1)) → motive x x_1 |
Lean.ClassState._sizeOf_inst | Lean.Class | SizeOf Lean.ClassState |
SemilatInfCat.instConcreteCategoryInfTopHomX._proof_3 | Mathlib.Order.Category.Semilat | ∀ {X : SemilatInfCat} (x : X.X), (CategoryTheory.CategoryStruct.id X) x = x |
UniformSpace.Completion.completionSeparationQuotientEquiv._proof_2 | Mathlib.Topology.UniformSpace.Completion | ∀ (α : Type u_1) [inst : UniformSpace α] (a : UniformSpace.Completion α),
UniformSpace.Completion.extension (SeparationQuotient.lift' UniformSpace.Completion.coe')
(UniformSpace.Completion.map SeparationQuotient.mk a) =
a |
of_eq_false | Init.SimpLemmas | ∀ {p : Prop}, p = False → ¬p |
_private.Mathlib.NumberTheory.ZetaValues.0.bernoulliFun_mul._simp_1_2 | Mathlib.NumberTheory.ZetaValues | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c |
ContinuousLinearMapWOT.instAddCommGroup | Mathlib.Analysis.LocallyConvex.WeakOperatorTopology | {𝕜₁ : Type u_1} →
{𝕜₂ : Type u_2} →
[inst : NormedField 𝕜₁] →
[inst_1 : NormedField 𝕜₂] →
{σ : 𝕜₁ →+* 𝕜₂} →
{E : Type u_3} →
{F : Type u_4} →
[inst_2 : AddCommGroup E] →
[inst_3 : TopologicalSpace E] →
[inst_4 : Module 𝕜₁ E] →
[inst_5 : AddCommGroup F] →
[inst_6 : TopologicalSpace F] →
[inst_7 : Module 𝕜₂ F] → [IsTopologicalAddGroup F] → AddCommGroup (E →SWOT[σ] F) |
Pi.instLTLexForall | Mathlib.Order.PiLex | {ι : Type u_1} → {β : ι → Type u_2} → [LT ι] → [(a : ι) → LT (β a)] → LT (Lex ((i : ι) → β i)) |
AlternatingMap.domLCongr._proof_1 | Mathlib.LinearAlgebra.Alternating.Basic | ∀ (R : Type u_1) [inst : Semiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (N : Type u_3)
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] (ι : Type u_4) {M₂ : Type u_5} [inst_5 : AddCommMonoid M₂]
[inst_6 : Module R M₂] (e : M ≃ₗ[R] M₂) (x x_1 : M [⋀^ι]→ₗ[R] N),
(x + x_1).compLinearMap ↑e.symm = (x + x_1).compLinearMap ↑e.symm |
Lean.Parser.Command.export._regBuiltin.Lean.Parser.Command.export.parenthesizer_13 | Lean.Parser.Command | IO Unit |
Real.cos_add | Mathlib.Analysis.Complex.Trigonometric | ∀ (x y : ℝ), Real.cos (x + y) = Real.cos x * Real.cos y - Real.sin x * Real.sin y |
pointedToTwoPSndForgetCompBipointedToPointedSndAdjunction._proof_5 | Mathlib.CategoryTheory.Category.TwoP | ∀ (X : Pointed) (Y : TwoP) (f : pointedToTwoPSnd.obj X ⟶ Y),
f.hom.toFun (pointedToTwoPSnd.obj X).toBipointed.toProd.2 = Y.toBipointed.toProd.2 |
ArithmeticFunction.vonMangoldt_sum | Mathlib.NumberTheory.ArithmeticFunction.VonMangoldt | ∀ {n : ℕ}, ∑ i ∈ n.divisors, ArithmeticFunction.vonMangoldt i = Real.log ↑n |
IsEvenlyCovered.subtypeVal_comp | Mathlib.Topology.Covering.Basic | ∀ {E : Type u_1} {X : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] (s : Set X) {I : Type u_3}
[inst_2 : TopologicalSpace I],
IsOpen s → ∀ {x : ↑s} {f : E → ↑s}, IsEvenlyCovered f x I → IsEvenlyCovered (Subtype.val ∘ f) (↑x) I |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.