name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.Limits.preservesColimits_unop | Mathlib.CategoryTheory.Limits.Preserves.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor Cᵒᵖ Dᵒᵖ) [CategoryTheory.Limits.PreservesLimits F],
CategoryTheory.Limits.PreservesColimits F.unop | If `F : Cᵒᵖ ⥤ Dᵒᵖ` preserves limits, then `F.unop : C ⥤ D` preserves colimits. | true |
Representation.ofDistribMulAction_apply_apply | Mathlib.RepresentationTheory.Basic | ∀ {k : Type u_1} {G : Type u_2} {A : Type u_3} [inst : Semiring k] [inst_1 : Monoid G] [inst_2 : AddCommMonoid A]
[inst_3 : Module k A] [inst_4 : DistribMulAction G A] [inst_5 : SMulCommClass G k A] (g : G) (a : A),
((Representation.ofDistribMulAction k G A) g) a = g • a | null | true |
Set.image_neg_uIcc | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [IsOrderedAddMonoid α] (a b : α),
Neg.neg '' Set.uIcc a b = Set.uIcc (-a) (-b) | null | true |
Fin.ctorIdx | Init.Prelude | {n : ℕ} → Fin n → ℕ | null | false |
CategoryTheory.Limits.coconeOfConeUnop_ι | 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 : CategoryTheory.Limits.Cone F.unop),
(CategoryTheory.Limits.coconeOfConeUnop c).ι = CategoryTheory.NatTrans.removeUnop c.π | null | true |
System.Platform.numBits_pos._simp_1 | Init.System.Platform | (0 < System.Platform.numBits) = True | null | false |
MeasurableSpace.comap_le_comap_pi | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {β : Type u_2} {δ : Type u_4} {X : δ → Type u_6} [inst : (a : δ) → MeasurableSpace (X a)] {g : (a : δ) → β → X a}
(a : δ), MeasurableSpace.comap (g a) inferInstance ≤ MeasurableSpace.comap (fun b c => g c b) MeasurableSpace.pi | null | true |
Equiv.addLeft | Mathlib.Algebra.Group.Units.Equiv | {G : Type u_5} → [AddGroup G] → G → Equiv.Perm G | Left addition in an `AddGroup` is a permutation of the underlying type. | true |
_private.Mathlib.Algebra.Polynomial.FieldDivision.0.Polynomial.degree_mod_lt._simp_1_1 | Mathlib.Algebra.Polynomial.FieldDivision | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, p.Monic = (p.leadingCoeff = 1) | null | false |
Polynomial.lsum._proof_2 | Mathlib.Algebra.Polynomial.Coeff | ∀ {R : Type u_3} {A : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : Semiring A] [inst_2 : AddCommMonoid M]
[inst_3 : Module R A] [inst_4 : Module R M] (f : ℕ → A →ₗ[R] M) (p q : Polynomial A),
((p + q).sum fun x1 x2 => (f x1) x2) = (p.sum fun x1 x2 => (f x1) x2) + q.sum fun x1 x2 => (f x1) x2 | null | false |
Lean.Omega.Constraint.addInequality_sat | Init.Omega.Constraint | ∀ {c : ℤ} {x y : Lean.Omega.Coeffs}, c + x.dot y ≥ 0 → { lowerBound := some (-c), upperBound := none }.sat' x y = true | null | true |
CategoryTheory.Functor.mapDifferentialObject._proof_3 | Mathlib.CategoryTheory.DifferentialObject | ∀ {S : Type u_3} [inst : AddMonoidWithOne S] {C : Type u_2} [inst_1 : CategoryTheory.Category.{u_1, u_2} C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_3 : CategoryTheory.HasShift C S] (D : Type u_5)
[inst_4 : CategoryTheory.Category.{u_4, u_5} D] [inst_5 : CategoryTheory.Limits.HasZeroMorphisms D]
... | null | false |
_private.Mathlib.MeasureTheory.OuterMeasure.Caratheodory.0.MeasureTheory.OuterMeasure.top_caratheodory._simp_1_1 | Mathlib.MeasureTheory.OuterMeasure.Caratheodory | ∀ {α : Type u} [inst : LE α] [inst_1 : OrderTop α] {a : α}, (a ≤ ⊤) = True | null | false |
SSet.relativeCellComplexOfMono.range_r_app_union_range_b_app | Mathlib.AlgebraicTopology.SimplicialSet.Skeleton | ∀ {X Y : SSet} (i : X ⟶ Y) (d : ℕ) (n : SimplexCategoryᵒᵖ),
Set.range ⇑(CategoryTheory.ConcreteCategory.hom ((SSet.relativeCellComplexOfMono.r i d).app n)) ∪
Set.range ⇑(CategoryTheory.ConcreteCategory.hom ((SSet.relativeCellComplexOfMono.b i d).app n)) =
Set.univ | null | true |
CategoryTheory.Limits.Cocone.fromStructuredArrow_map_hom | Mathlib.CategoryTheory.Limits.ConeCategory | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
(F : CategoryTheory.Functor J C) {X Y : CategoryTheory.StructuredArrow F (CategoryTheory.Functor.const J)}
(f : X ⟶ Y),
((CategoryTheory.Limits.Cocone.fromStructuredArrow F).map f).hom = Categor... | null | true |
Frm.instCategory._proof_3 | Mathlib.Order.Category.Frm | ∀ {W X Y Z : Frm} (f : W.Hom X) (g : X.Hom Y) (h : Y.Hom Z),
{ hom' := h.hom'.comp { hom' := g.hom'.comp f.hom' }.hom' } =
{ hom' := { hom' := h.hom'.comp g.hom' }.hom'.comp f.hom' } | null | false |
_aux_Mathlib_Algebra_Group_Equiv_Defs___unexpand_AddEquiv_1 | Mathlib.Algebra.Group.Equiv.Defs | Lean.PrettyPrinter.Unexpander | null | false |
WithLp.prod_nndist_eq_of_L1 | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ {α : Type u_2} {β : Type u_3} [inst : SeminormedAddCommGroup α] [inst_1 : SeminormedAddCommGroup β]
(x y : WithLp 1 (α × β)), nndist x y = nndist x.fst y.fst + nndist x.snd y.snd | null | true |
CategoryTheory.Equivalence.powNat.match_1 | Mathlib.CategoryTheory.Equivalence | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → (Unit → motive 1) → ((n : ℕ) → motive n.succ.succ) → motive x | null | false |
Turing.PartrecToTM2.K'.elim.eq_2 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (a b c d : List Turing.PartrecToTM2.Γ'), Turing.PartrecToTM2.K'.elim a b c d Turing.PartrecToTM2.K'.rev = b | null | true |
Order.IsPredLimit.dual | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {a : α} [inst : Preorder α], Order.IsPredLimit a → Order.IsSuccLimit (OrderDual.toDual a) | **Alias** of the reverse direction of `Order.isSuccLimit_toDual_iff`. | true |
List.«_aux_Init_Data_List_Basic___macroRules_List_term_<+__1» | Init.Data.List.Basic | Lean.Macro | null | false |
Multiset.exists_max_image | Mathlib.Data.Finset.Max | ∀ {α : Type u_7} {R : Type u_8} [inst : LinearOrder R] (f : α → R) {s : Multiset α}, s ≠ 0 → ∃ y ∈ s, ∀ z ∈ s, f z ≤ f y | null | true |
_private.Lean.Elab.Tactic.Monotonicity.0.Lean.Meta.Monotonicity.initFn.match_1._@.Lean.Elab.Tactic.Monotonicity.1250514167._hygCtx._hyg.2 | Lean.Elab.Tactic.Monotonicity | (motive : Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr → Sort u_1) →
(x : Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr) →
((xs : Array Lean.Expr) → (fst : Array Lean.BinderInfo) → (targetTy : Lean.Expr) → motive (xs, fst, targetTy)) →
motive x | null | false |
WeierstrassCurve.Affine.CoordinateRing.basis | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | {R : Type r} →
[inst : CommRing R] → (W' : WeierstrassCurve.Affine R) → Module.Basis (Fin 2) (Polynomial R) W'.CoordinateRing | The power basis `{1, Y}` for `R[W]` over `R[X]`. | true |
Subsemigroup.unop_sInf | Mathlib.Algebra.Group.Subsemigroup.MulOpposite | ∀ {M : Type u_2} [inst : Mul M] (S : Set (Subsemigroup Mᵐᵒᵖ)), (sInf S).unop = sInf (Subsemigroup.op ⁻¹' S) | null | true |
LinOrd._sizeOf_inst | Mathlib.Order.Defs.LinearOrder | SizeOf LinOrd | null | false |
AlgebraicGeometry.AffineSpace.isOpenMap_over | Mathlib.AlgebraicGeometry.AffineSpace | ∀ {n : Type u} (S : AlgebraicGeometry.Scheme), IsOpenMap ⇑(AlgebraicGeometry.AffineSpace n S ↘ S) | null | true |
_private.Mathlib.Combinatorics.Additive.PluenneckeRuzsa.0.Finset.mul_aux | Mathlib.Combinatorics.Additive.PluenneckeRuzsa | ∀ {G : Type u_1} [inst : DecidableEq G] [inst_1 : CommGroup G] {A B C : Finset G},
A.Nonempty →
A ⊆ B →
(∀ A' ∈ B.powerset.erase ∅, ↑(A * C).card / ↑A.card ≤ ↑(A' * C).card / ↑A'.card) →
∀ A' ⊆ A, (A * C).card * A'.card ≤ (A' * C).card * A.card | null | true |
Option.mem_filter_iff | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {a : α} {o : Option α}, a ∈ Option.filter p o ↔ a ∈ o ∧ p a = true | null | true |
NumberField.RingOfIntegers.instSMulDistribClass | Mathlib.NumberTheory.NumberField.Basic | ∀ (K : Type u_1) [inst : Field K] {G : Type u_3} [inst_1 : Group G] [inst_2 : MulSemiringAction G K],
SMulDistribClass G (NumberField.RingOfIntegers K) K | null | true |
Lean.Meta.Grind.Methods.mk.sizeOf_spec | Lean.Meta.Tactic.Grind.Types | ∀ (propagateUp propagateDown : Lean.Meta.Grind.Propagator) (evalTactic : Lean.Meta.Grind.EvalTactic),
sizeOf { propagateUp := propagateUp, propagateDown := propagateDown, evalTactic := evalTactic } = 1 | null | true |
Bundle.Trivialization.linearMapAt_symmₗ | Mathlib.Topology.VectorBundle.Basic | ∀ {R : Type u_1} {B : Type u_2} {F : Type u_3} {E : B → Type u_4} [inst : Semiring R] [inst_1 : TopologicalSpace F]
[inst_2 : TopologicalSpace B] [inst_3 : TopologicalSpace (Bundle.TotalSpace F E)] [inst_4 : AddCommMonoid F]
[inst_5 : Module R F] [inst_6 : (x : B) → AddCommMonoid (E x)] [inst_7 : (x : B) → Module R... | null | true |
LieModuleHom.restrictLie._proof_1 | Mathlib.Algebra.Lie.Subalgebra | ∀ {R : Type u_2} {L : Type u_1} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] {M : Type u_4}
[inst_3 : AddCommGroup M] [inst_4 : LieRingModule L M] {N : Type u_3} [inst_5 : AddCommGroup N]
[inst_6 : LieRingModule L N] [inst_7 : Module R N] [inst_8 : Module R M] (f : M →ₗ⁅R,L⁆ N) (L' : LieSubalg... | null | false |
CategoryTheory.linearYoneda._proof_2 | Mathlib.CategoryTheory.Linear.Yoneda | ∀ (R : Type u_3) [inst : Ring R] (C : Type u_1) [inst_1 : CategoryTheory.Category.{u_2, u_1} C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C] (X : C) (X_1 : Cᵒᵖ),
ModuleCat.ofHom (CategoryTheory.Linear.leftComp R X (CategoryTheory.CategoryStruct.id X_1).unop) =
CategoryTheory.Cate... | null | false |
Finset.strongInduction_eq | Mathlib.Data.Finset.Card | ∀ {α : Type u_1} {p : Finset α → Sort u_4} (H : (s : Finset α) → ((t : Finset α) → t ⊂ s → p t) → p s) (s : Finset α),
Finset.strongInduction H s = H s fun t x => Finset.strongInduction H t | null | true |
Lean.Meta.Origin.other.sizeOf_spec | Lean.Meta.Tactic.Simp.SimpTheorems | ∀ (name : Lean.Name), sizeOf (Lean.Meta.Origin.other name) = 1 + sizeOf name | null | true |
iteratedDeriv_const_smul | Mathlib.Analysis.Calculus.IteratedDeriv.Lemmas | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {x : 𝕜} {R : Type u_3} [inst_3 : DistribSMul R F] [SMulCommClass 𝕜 R F]
[ContinuousConstSMul R F] {n : ℕ} {f : 𝕜 → F},
ContDiffAt 𝕜 (↑n) f x → ∀ (c : R), iteratedDeriv n (c • f) x =... | null | true |
isAddRightRegular_toDual | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : AddMonoid α] {a : α}, IsAddRightRegular (OrderDual.toDual a) ↔ IsAddRightRegular a | null | true |
_private.Lean.Meta.Tactic.Grind.AC.PP.0.Lean.Meta.Grind.AC.instMonadGetStructM | Lean.Meta.Tactic.Grind.AC.PP | Lean.Meta.Grind.AC.MonadGetStruct Lean.Meta.Grind.AC.M✝ | null | true |
Filter.eventually_all_finset | Mathlib.Order.Filter.Finite | ∀ {α : Type u} {ι : Type u_2} (I : Finset ι) {l : Filter α} {p : ι → α → Prop},
(∀ᶠ (x : α) in l, ∀ i ∈ I, p i x) ↔ ∀ i ∈ I, ∀ᶠ (x : α) in l, p i x | null | true |
ProbabilityTheory.bayesRisk_fintype | Mathlib.Probability.Decision.Risk.Countable | ∀ {Θ : Type u_1} {𝓧 : Type u_3} {𝓨 : Type u_5} {mΘ : MeasurableSpace Θ} {m𝓧 : MeasurableSpace 𝓧}
{m𝓨 : MeasurableSpace 𝓨} {ℓ : Θ → 𝓨 → ENNReal} {P : ProbabilityTheory.Kernel Θ 𝓧} {π : MeasureTheory.Measure Θ}
[inst : Fintype Θ] [MeasurableSingletonClass Θ],
ProbabilityTheory.bayesRisk ℓ P π =
⨅ κ, ⨅ (... | null | true |
_private.Lean.Meta.Tactic.TryThis.0.Lean.Meta.Tactic.TryThis.mkExactSuggestionSyntax | Lean.Meta.Tactic.TryThis | Lean.Expr → Bool → Lean.MetaM (Lean.TSyntax `tactic × Lean.MessageData) | Returns the syntax for an `exact` or `refine` (as indicated by `useRefine`) tactic corresponding to
`e` as well as a `MessageData` representation with hover information.
If `exposeNames` is `true`, prepends the tactic with `expose_names.` Note that the tactic is
always generated within `withExposedNames` to avoid gener... | true |
DirectedSystem | Mathlib.Order.DirectedInverseSystem | {ι : Type u_1} → [inst : Preorder ι] → (F : ι → Type u_4) → (⦃i j : ι⦄ → i ≤ j → F i → F j) → Prop | A directed system is a functor from a category (directed poset) to another category. | true |
AlgEquiv.toLinearEquiv_refl | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type uR} {A₁ : Type uA₁} [inst : CommSemiring R] [inst_1 : Semiring A₁] [inst_2 : Algebra R A₁],
↑AlgEquiv.refl = LinearEquiv.refl R A₁ | null | true |
CommAlgCat.tensorHom_hom | Mathlib.Algebra.Category.CommAlgCat.Monoidal | ∀ {R : Type u} [inst : CommRing R] {A B C D : CommAlgCat R} (f : A ⟶ C) (g : B ⟶ D),
CommAlgCat.Hom.hom (CategoryTheory.MonoidalCategoryStruct.tensorHom f g) =
Algebra.TensorProduct.map (CommAlgCat.Hom.hom f) (CommAlgCat.Hom.hom g) | null | true |
_private.Mathlib.Algebra.BigOperators.Group.Finset.Piecewise.0.Finset.prod_dite_of_true._proof_1_6 | Mathlib.Algebra.BigOperators.Group.Finset.Piecewise | ∀ {ι : Type u_1} {M : Type u_2} {s : Finset ι} {p : ι → Prop} [inst : DecidablePred p] (h : ∀ i ∈ s, p i)
(f : (i : ι) → p i → M) (g : (i : ι) → ¬p i → M) (a : ι) (ha : a ∈ s),
(if hi : p a then f a hi else g a hi) = f ↑⟨a, ha⟩ ⋯ | null | false |
LinearMap.addCommGroup._proof_1 | Mathlib.Algebra.Module.LinearMap.Defs | ∀ {R₁ : Type u_1} {R₂ : Type u_2} {M : Type u_3} {N₂ : Type u_4} [inst : Semiring R₁] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommGroup N₂] [inst_4 : Module R₁ M] [inst_5 : Module R₂ N₂]
{σ₁₂ : R₁ →+* R₂}, autoParam (∀ (a b : M →ₛₗ[σ₁₂] N₂), a - b = a + -b) SubNegMonoid.sub_eq_add_neg._autoPa... | null | false |
Lean.Elab.Structural.IndGroupInst.levels | Lean.Elab.PreDefinition.Structural.IndGroupInfo | Lean.Elab.Structural.IndGroupInst → List Lean.Level | null | true |
_private.Lean.Meta.Tactic.AC.Main.0.Lean.Meta.AC.toACExpr.toPreExpr | Lean.Meta.Tactic.AC.Main | Lean.Expr → Lean.Expr → StateT Lean.ExprSet Lean.MetaM Lean.Meta.AC.PreExpr | null | true |
Std.Http.Response.Builder.mk.injEq | Std.Http.Data.Response | ∀ (line : Std.Http.Response.Head) (extensions : Std.Http.Extensions) (line_1 : Std.Http.Response.Head)
(extensions_1 : Std.Http.Extensions),
({ line := line, extensions := extensions } = { line := line_1, extensions := extensions_1 }) =
(line = line_1 ∧ extensions = extensions_1) | null | true |
AlgebraicGeometry.instQuasiSeparatedOfMonoScheme | Mathlib.AlgebraicGeometry.Morphisms.QuasiSeparated | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [CategoryTheory.Mono f], AlgebraicGeometry.QuasiSeparated f | null | true |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Roo.succ_mem_succ_succ_iff._simp_1_1 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : LT α] [DecidableLT α] [inst_2 : Std.PRange.UpwardEnumerable α]
[Std.PRange.LinearlyUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLT α]
[inst_5 : Std.PRange.InfinitelyUpwardEnumerable α] [Std.Rxo.IsAlwaysFinite α] [Std.PRange.LawfulUpwardEnumerable α]
{lo hi a : α}, (a ∈ (Std.PRange.... | null | false |
Lean.Parser.ParserContext.suppressInsideQuot._inherited_default | Lean.Parser.Types | Bool | null | false |
EuclideanSpace.nndist_eq | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {𝕜 : Type u_7} [inst : RCLike 𝕜] {n : Type u_8} [inst_1 : Fintype n] (x y : EuclideanSpace 𝕜 n),
nndist x y = NNReal.sqrt (∑ i, nndist (x.ofLp i) (y.ofLp i) ^ 2) | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0.BitVec.reduceSLT._regBuiltin.BitVec.reduceSLT.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.1265938610._hygCtx._hyg.18 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | IO Unit | null | false |
Unitization.instSemiring | Mathlib.Algebra.Algebra.Unitization | {R : Type u_1} →
{A : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : NonUnitalSemiring A] →
[inst_2 : Module R A] → [IsScalarTower R A A] → [SMulCommClass R A A] → Semiring (Unitization R A) | null | true |
Batteries.PairingHeapImp.instDecidableNoSibling | Batteries.Data.PairingHeap | {α : Type u_1} → {s : Batteries.PairingHeapImp.Heap α} → Decidable s.NoSibling | null | true |
CategoryTheory.Grp.mk | Mathlib.CategoryTheory.Monoidal.Grp | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
(X : C) → [grp : CategoryTheory.GrpObj X] → CategoryTheory.Grp C | null | true |
AddSubgroupClass.coe_zmod_smul | Mathlib.Data.ZMod.Basic | ∀ {n : ℕ} {S : Type u_1} {G : Type u_2} [inst : AddCommGroup G] [inst_1 : SetLike S G] [inst_2 : AddSubgroupClass S G]
{K : S} [inst_3 : Module (ZMod n) G] (a : ZMod n) (x : ↥K), ↑(a • x) = a • ↑x | null | true |
Std.Tactic.BVDecide.LRAT.Internal.Entails.eval | Std.Tactic.BVDecide.LRAT.Internal.Entails | {α : Type u} → {β : Type v} → [self : Std.Tactic.BVDecide.LRAT.Internal.Entails α β] → (α → Bool) → β → Prop | null | true |
Finset.emultiplicity_prod | Mathlib.RingTheory.Multiplicity | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [IsCancelMulZero α] {β : Type u_3} {p : α},
Prime p → ∀ (s : Finset β) (f : β → α), emultiplicity p (∏ x ∈ s, f x) = ∑ x ∈ s, emultiplicity p (f x) | null | true |
Lean.Level.isAlreadyNormalizedCheap._f | Lean.Level | (x : Lean.Level) → Lean.Level.below x → Bool | null | false |
Lean.Linter.MissingDocs.handleMutual | Lean.Linter.MissingDocs | Lean.Linter.MissingDocs.Handler | null | true |
Geometry.SimplicialComplex.ofSubcomplex_faces | Mathlib.Analysis.Convex.SimplicialComplex.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Ring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommGroup E]
[inst_3 : Module 𝕜 E] (K : Geometry.SimplicialComplex 𝕜 E) (faces : Set (Finset E)) (subset : faces ⊆ K.faces)
(down_closed : IsLowerSet faces), (K.ofSubcomplex faces subset down_closed).faces = faces | null | true |
RCLike.conjAe_coe | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K], ⇑RCLike.conjAe = ⇑(starRingEnd K) | null | true |
LinearEquiv.ofEq.congr_simp | Mathlib.LinearAlgebra.Basis.Basic | ∀ {R : Type u_1} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] {module_M : Module R M}
(p q : Submodule R M) (h : p = q), LinearEquiv.ofEq p q h = LinearEquiv.ofEq p q h | null | true |
RCLike.im_eq_zero | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K], RCLike.I = 0 → ∀ (z : K), RCLike.im z = 0 | null | true |
CategoryTheory.Limits.BinaryBicone.isBilimitOfCokernelFst._proof_1 | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C}
(b : CategoryTheory.Limits.BinaryBicone X Y) {T : C} (f : X ⟶ T) (g : Y ⟶ T),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.BinaryCofan.inl b.toCocone)
(CategoryTheory.CategoryStruct.co... | null | false |
_private.Mathlib.NumberTheory.FLT.Polynomial.0.Polynomial.flt_catalan_aux._simp_1_5 | Mathlib.NumberTheory.FLT.Polynomial | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Add M] [inst_1 : Add N] [inst_2 : FunLike F M N]
[AddHomClass F M N] (f : F) (x y : M), f x + f y = f (x + y) | null | false |
Std.Format.tag.sizeOf_spec | Init.Data.Format.Basic | ∀ (a : ℕ) (a_1 : Std.Format), sizeOf (Std.Format.tag a a_1) = 1 + sizeOf a + sizeOf a_1 | null | true |
SetRel.rightDual_mem_leftFixedPoint | Mathlib.Order.Rel.GaloisConnection | ∀ {α : Type u_1} {β : Type u_2} (R : SetRel α β) (I : Set β), R.rightDual I ∈ R.leftFixedPoints | `rightDual` maps every element `I` to `leftFixedPoints`. | true |
Filter.EventuallyEq.nhdsNE_deriv | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f f₁ : 𝕜 → F} {x : 𝕜}, f₁ =ᶠ[nhdsWithin x {x}ᶜ] f → deriv f₁ =ᶠ[nhdsWithin x {x}ᶜ] deriv f | null | true |
CategoryTheory.EquivalenceRelation.casesOn | Mathlib.CategoryTheory.EquivalenceRelation | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{R X : C} →
{p₁ p₂ : R ⟶ X} →
{motive : CategoryTheory.EquivalenceRelation p₁ p₂ → Sort u} →
(t : CategoryTheory.EquivalenceRelation p₁ p₂) →
((toReflexiveRelation : CategoryTheory.ReflexiveRelation p₁ p₂) →
... | null | false |
ProofWidgets.GetExprPresentationParams.rec | ProofWidgets.Presentation.Expr | {motive : ProofWidgets.GetExprPresentationParams → Sort u} →
((expr : Lean.Server.WithRpcRef ProofWidgets.ExprWithCtx) →
(name : Lean.Name) → motive { expr := expr, name := name }) →
(t : ProofWidgets.GetExprPresentationParams) → motive t | null | false |
_private.Mathlib.NumberTheory.RamificationInertia.Ramification.0.Ideal._aux_Mathlib_NumberTheory_RamificationInertia_Ramification___unexpand_Algebra_algebraMap_1 | Mathlib.NumberTheory.RamificationInertia.Ramification | Lean.PrettyPrinter.Unexpander | null | false |
List.le_nil._simp_1 | Init.Data.List.Lex | ∀ {α : Type u_1} [inst : LT α] {l : List α}, (l ≤ []) = (l = []) | null | false |
String.instLEPos_1 | Init.Data.String.Defs | {s : String.Slice} → LE s.Pos | null | true |
_private.Lean.Meta.RecursorInfo.0.Lean.Meta.getMotiveLevel._sparseCasesOn_1 | Lean.Meta.RecursorInfo | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((u : Lean.Level) → motive (Lean.Expr.sort u)) → (Nat.hasNotBit 8 t.ctorIdx → motive t) → motive t | null | false |
_private.Aesop.Tree.Data.0.Aesop.GoalId.succ.match_1 | Aesop.Tree.Data | (motive : Aesop.GoalId → Sort u_1) → (x : Aesop.GoalId) → ((n : ℕ) → motive { toNat := n }) → motive x | null | false |
Turing.PartrecToTM2.copy_ok | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (q : Turing.PartrecToTM2.Λ') (s : Option Turing.PartrecToTM2.Γ') (a b c d : List Turing.PartrecToTM2.Γ'),
StateTransition.Reaches₁ (Turing.TM2.step Turing.PartrecToTM2.tr)
{ l := some q.copy, var := s, stk := Turing.PartrecToTM2.K'.elim a b c d }
{ l := some q, var := none, stk := Turing.PartrecToTM2.K'.eli... | null | true |
Std.HashMap.Equiv.getElem!_eq | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{k : α} [inst : Inhabited β], m₁.Equiv m₂ → m₁[k]! = m₂[k]! | null | true |
hfdifferential._proof_10 | Mathlib.Geometry.Manifold.DerivationBundle | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_6} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_7} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_5}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_2} [inst_6 : NormedAddComm... | null | false |
ProbabilityTheory.Kernel.IsProper.setLIntegral_eq_indicator_mul_lintegral | Mathlib.Probability.Kernel.Proper | ∀ {X : Type u_1} {𝓑 𝓧 : MeasurableSpace X} {π : ProbabilityTheory.Kernel X X} {B : Set X} {f : X → ENNReal},
π.IsProper →
𝓑 ≤ 𝓧 →
Measurable f → MeasurableSet B → ∀ (x₀ : X), ∫⁻ (x : X) in B, f x ∂π x₀ = B.indicator 1 x₀ * ∫⁻ (x : X), f x ∂π x₀ | null | true |
Std.TreeMap.minKey_modify_eq_minKey | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [inst : Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] {k : α} {f : β → β} {he : (t.modify k f).isEmpty = false}, (t.modify k f).minKey he = t.minKey ⋯ | null | true |
BooleanSubalgebra.topEquiv._proof_1 | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_1} [inst : BooleanAlgebra α] {a b : ↥⊤},
(Equiv.Set.univ α) a ≤ (Equiv.Set.univ α) b ↔ (Equiv.Set.univ α) a ≤ (Equiv.Set.univ α) b | null | false |
Int.Linear.Poly.mul_minus_one_getConst_eq | Init.Data.Int.Linear | ∀ (p : Int.Linear.Poly), (p.mul (-1)).getConst = -p.getConst | null | true |
BddLat.hom_comp | Mathlib.Order.Category.BddLat | ∀ {X Y Z : Lat} (f : X ⟶ Y) (g : Y ⟶ Z),
Lat.Hom.hom (CategoryTheory.CategoryStruct.comp f g) = (Lat.Hom.hom g).comp (Lat.Hom.hom f) | null | true |
NumberField.InfinitePlace.one_le_of_lt_one | Mathlib.NumberTheory.NumberField.InfinitePlace.Basic | ∀ {K : Type u_1} [inst : Field K] [NumberField K] {w : NumberField.InfinitePlace K} {a : NumberField.RingOfIntegers K},
a ≠ 0 → (∀ ⦃z : NumberField.InfinitePlace K⦄, z ≠ w → z ↑a < 1) → 1 ≤ w ↑a | null | true |
TensorProduct.tmul_add | Mathlib.LinearAlgebra.TensorProduct.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_7} {N : Type u_8} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] (m : M) (n₁ n₂ : N),
m ⊗ₜ[R] (n₁ + n₂) = m ⊗ₜ[R] n₁ + m ⊗ₜ[R] n₂ | null | true |
CategoryTheory.Core.functorToCore._proof_4 | Mathlib.CategoryTheory.Core | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {G : Type u_4} [inst_1 : CategoryTheory.Groupoid G]
(F : CategoryTheory.Functor G C) {X Y : G} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.Groupoid.inv f)) (F.map f) =
CategoryTheory.CategoryStruct.id { of := F.obj Y }.of | null | false |
Lean.CollectMVars.State.mk._flat_ctor | Lean.Util.CollectMVars | Lean.ExprSet → Array Lean.MVarId → Lean.CollectMVars.State | null | false |
CategoryTheory.piEquivalenceFunctorDiscreteCompEvaluationIso._proof_2 | Mathlib.CategoryTheory.Discrete.Basic | ∀ (C : Type u_3) [inst : CategoryTheory.Category.{u_2, u_3} C] {J : Type u_1} (j : J) {X Y : J → C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.piEquivalenceFunctorDiscrete J C).functor.comp
((CategoryTheory.evaluation (CategoryTheory.Discrete J) C).obj { as := j })).map
... | null | false |
WType.toList._sunfold | Mathlib.Data.W.Constructions | (γ : Type u) → WType (WType.Listβ γ) → List γ | null | false |
Metric.unitBall.instSemigroupWithZero._proof_2 | Mathlib.Analysis.Normed.Field.UnitBall | ∀ {𝕜 : Type u_1} [inst : NonUnitalSeminormedRing 𝕜] (x : ↑(Metric.ball 0 1)), x * 0 = 0 | null | false |
Std.TreeMap.getEntryGE | Std.Data.TreeMap.AdditionalOperations | {α : Type u} →
{β : Type v} →
{cmp : α → α → Ordering} →
[Std.TransCmp cmp] → (t : Std.TreeMap α β cmp) → (k : α) → (∃ a ∈ t, (cmp a k).isGE = true) → α × β | Given a proof that such a mapping exists, retrieves the key-value pair with the smallest key that is
greater than or equal to the given key.
| true |
CategoryTheory.Quotient.linear._proof_2 | Mathlib.CategoryTheory.Quotient.Linear | ∀ (R : Type u_3) {C : Type u_2} [inst : Semiring R] [inst_1 : CategoryTheory.Category.{u_1, u_2} C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C] (r : HomRel C)
[inst_4 : CategoryTheory.Congruence r] (hr : ∀ (a : R) ⦃X Y : C⦄ (f₁ f₂ : X ⟶ Y), r f₁ f₂ → r (a • f₁) (a • f₂))
[inst_5 :... | null | false |
Std.Tactic.BVDecide.BVExpr.Cache.insert.match_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | {aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit} →
(motive : Std.Tactic.BVDecide.BVExpr.Cache aig → Sort u_1) →
(cache : Std.Tactic.BVDecide.BVExpr.Cache aig) →
((map : Std.DHashMap Std.Tactic.BVDecide.BVExpr.Cache.Key fun k => Vector Std.Sat.AIG.Fanin k.w) →
(hbound :
∀ {i : ℕ} (k : St... | null | false |
_private.Mathlib.Data.Int.CardIntervalMod.0.Int.Ico_filter_modEq_eq._simp_1_7 | Mathlib.Data.Int.CardIntervalMod | ∀ {n a b : ℤ}, (a ≡ b [ZMOD n]) = (n ∣ b - a) | null | false |
_private.Mathlib.Tactic.CasesM.0.Mathlib.Tactic.matchPatterns.match_1 | Mathlib.Tactic.CasesM | (motive : Option (Lean.Expr × Array Lean.Expr) → Sort u_1) →
(__do_lift : Option (Lean.Expr × Array Lean.Expr)) →
((fst : Lean.Expr) → motive (some (fst, #[]))) →
((x : Option (Lean.Expr × Array Lean.Expr)) → motive x) → motive __do_lift | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.