name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ProbabilityTheory.mgf_congr_identDistrib | Mathlib.Probability.Moments.Basic | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {X : Ω → ℝ} {μ : MeasureTheory.Measure Ω} {Ω' : Type u_3}
{mΩ' : MeasurableSpace Ω'} {μ' : MeasureTheory.Measure Ω'} {Y : Ω' → ℝ},
ProbabilityTheory.IdentDistrib X Y μ μ' → ProbabilityTheory.mgf X μ = ProbabilityTheory.mgf Y μ' | null | true |
Lean.Parser.Tactic.ImpossibleConfig.recOn | Init.Tactics | {motive : Lean.Parser.Tactic.ImpossibleConfig → Sort u} →
(t : Lean.Parser.Tactic.ImpossibleConfig) → ((levels : Bool) → motive { levels := levels }) → motive t | null | false |
OrderIso.sumLexIicIoi_symm_apply_Iic | Mathlib.Order.Hom.Lex | ∀ {α : Type u_1} [inst : LinearOrder α] {x : α} (a : ↑(Set.Iic x)), (OrderIso.sumLexIicIoi x).symm ↑a = Sum.inl a | null | true |
ProofWidgets.Html._sizeOf_1 | ProofWidgets.Data.Html | ProofWidgets.Html → ℕ | null | false |
_private.Mathlib.Topology.Instances.EReal.Lemmas.0.EReal.continuousAt_mul_top_pos._simp_1_9 | Mathlib.Topology.Instances.EReal.Lemmas | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α}, (c < max a b) = (c < a ∨ c < b) | null | false |
CategoryTheory.Limits.Cone.extendHom_hom | 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} (s : CategoryTheory.Limits.Cone F) {X : C} (f : X ⟶ s.pt), (s.extendHom f).hom = f | null | true |
CategoryTheory.Mon.Hom.mk.sizeOf_spec | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{M N : CategoryTheory.Mon C} [inst_2 : SizeOf C] (hom : M.X ⟶ N.X) [isMonHom_hom : CategoryTheory.IsMonHom hom],
sizeOf { hom := hom, isMonHom_hom := isMonHom_hom } = 1 + sizeOf hom + sizeOf isMonHom_hom | null | true |
_private.Mathlib.Analysis.Normed.Module.PiTensorProduct.ProjectiveSeminorm.0.PiTensorProduct.mapL_add_smul_aux._proof_1_9 | Mathlib.Analysis.Normed.Module.PiTensorProduct.ProjectiveSeminorm | ∀ {𝕜 : Type u_4} [inst : NontriviallyNormedField 𝕜] {ι : Type u_1} {E : ι → Type u_2}
[inst_1 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)] {E' : ι → Type u_3}
[inst_3 : (i : ι) → SeminormedAddCommGroup (E' i)] [inst_4 : (i : ι) → NormedSpace 𝕜 (E' i)]
(f : (i : ι) → E i →... | null | false |
Lean.Elab.Tactic.nonempty_to_inhabited | Mathlib.Tactic.Inhabit | (α : Sort u_1) → Nonempty α → Inhabited α | Derives `Inhabited α` from `Nonempty α` with `Classical.choice`. | true |
AlgebraicGeometry.IsLocalIso.instIsMultiplicativeScheme | Mathlib.AlgebraicGeometry.Morphisms.LocalIso | CategoryTheory.MorphismProperty.IsMultiplicative @AlgebraicGeometry.IsLocalIso | null | true |
NonemptyChain.rec | Mathlib.Order.BourbakiWitt | {α : Type u_4} →
[inst : LE α] →
{motive : NonemptyChain α → Sort u} →
((carrier : Set α) →
(Nonempty' : carrier.Nonempty) →
(isChain' : IsChain (fun x1 x2 => x1 ≤ x2) carrier) →
motive { carrier := carrier, Nonempty' := Nonempty', isChain' := isChain' }) →
(t : N... | null | false |
Lean.Order.iSup | Std.Internal.Order.Basic | {α : Type u} → [Lean.Order.CompleteLattice α] → {ι : Type v} → (ι → α) → α | Indexed supremum | true |
le_of_pow_le_pow_left₀ | Mathlib.Algebra.Order.GroupWithZero.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : LinearOrder M₀] [PosMulStrictMono M₀] {a b : M₀} {n : ℕ}
[MulPosMono M₀], n ≠ 0 → 0 ≤ b → a ^ n ≤ b ^ n → a ≤ b | null | true |
PadicAlgCl.valuation_p | Mathlib.NumberTheory.Padics.Complex | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)], Valued.v ↑p = 1 / ↑p | The valuation of `p : PadicAlgCl p` is `1/p`. | true |
Nat.map_cast_int_atTop | Mathlib.Order.Filter.AtTopBot.Basic | Filter.map Nat.cast Filter.atTop = Filter.atTop | null | true |
QuotientGroup.mk_mul | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} [inst : Group G] (N : Subgroup G) [nN : N.Normal] (a b : G), ↑(a * b) = ↑a * ↑b | null | true |
Std.DTreeMap.contains_emptyc | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {k : α}, ∅.contains k = false | null | true |
Finset.weightedVSub | Mathlib.LinearAlgebra.AffineSpace.Combination | {k : Type u_1} →
{V : Type u_2} →
{P : Type u_3} →
[inst : Ring k] →
[inst_1 : AddCommGroup V] →
[inst_2 : Module k V] → [S : AddTorsor V P] → {ι : Type u_4} → Finset ι → (ι → P) → (ι → k) →ₗ[k] V | A weighted sum of the results of subtracting a default base point
from the given points, as a linear map on the weights. This is
intended to be used when the sum of the weights is 0; that condition
is specified as a hypothesis on those lemmas that require it. | true |
CategoryTheory.MorphismProperty.LeftFraction.unop_f | Mathlib.CategoryTheory.Localization.CalculusOfFractions | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W : CategoryTheory.MorphismProperty Cᵒᵖ} {X Y : Cᵒᵖ}
(φ : W.LeftFraction X Y), φ.unop.f = φ.f.unop | null | true |
MeasureTheory.AddContent.mk._flat_ctor | Mathlib.MeasureTheory.Measure.AddContent | {α : Type u_1} →
{G : Type u_2} →
[inst : AddCommMonoid G] →
{C : Set (Set α)} →
(toFun : Set α → G) →
toFun ∅ = 0 →
(∀ (I : Finset (Set α)), ↑I ⊆ C → (↑I).PairwiseDisjoint id → ⋃₀ ↑I ∈ C → toFun (⋃₀ ↑I) = ∑ u ∈ I, toFun u) →
MeasureTheory.AddContent G C | null | false |
_private.Mathlib.Tactic.Linarith.Preprocessing.0.Mathlib.Tactic.Linarith.nlinarithGetSquareProofs | Mathlib.Tactic.Linarith.Preprocessing | List Lean.Expr → Lean.MetaM (List Lean.Expr) | Get proofs of `-x^2 ≤ 0` and `-(x*x) ≤ 0`, when those terms appear in `ls` | true |
Int.natCast_toNat_eq_self | Init.Data.Int.LemmasAux | ∀ {a : ℤ}, ↑a.toNat = a ↔ 0 ≤ a | null | true |
Filter.EventuallyEq.lieBracketWithin_vectorField_eq_of_insert | Mathlib.Analysis.Calculus.VectorField | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {V W V₁ W₁ : E → E} {s : Set E} {x : E},
V₁ =ᶠ[nhdsWithin x (insert x s)] V →
W₁ =ᶠ[nhdsWithin x (insert x s)] W →
VectorField.lieBracketWithin 𝕜 V₁ W₁ s x = VectorField.lieBra... | null | true |
Lean.AxiomVal.isUnsafeEx | Lean.Declaration | Lean.AxiomVal → Bool | null | true |
BitVec.not_or_self | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x : BitVec w), ~~~x ||| x = BitVec.allOnes w | null | true |
_private.Lean.PrettyPrinter.Delaborator.Builtins.0.Lean.PrettyPrinter.Delaborator.delabLetE._sparseCasesOn_3 | Lean.PrettyPrinter.Delaborator.Builtins | {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 | null | false |
Std.ExtDHashMap.getKey?_inter_of_not_mem_left | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m₁ m₂ : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α}, k ∉ m₁ → (m₁ ∩ m₂).getKey? k = none | null | true |
_private.Lean.Server.FileWorker.SemanticHighlighting.0.Lean.Server.FileWorker.splitStr._proof_1 | Lean.Server.FileWorker.SemanticHighlighting | ∀ (text : Lean.FileMap) (pos : String.Pos.Raw),
∀ i ∈ [(text.toPosition pos).line:text.positions.size], i < text.positions.size | null | false |
Pi.intCast_def | Mathlib.Data.Int.Cast.Pi | ∀ {ι : Type u_1} {π : ι → Type u_2} [inst : (i : ι) → IntCast (π i)] (n : ℤ), ↑n = fun x => ↑n | null | true |
CategoryTheory.ObjectProperty.ColimitOfShape._sizeOf_1 | Mathlib.CategoryTheory.ObjectProperty.ColimitsOfShape | {C : Type u_1} →
{inst : CategoryTheory.Category.{v_1, u_1} C} →
{P : CategoryTheory.ObjectProperty C} →
{J : Type u'} →
{inst_1 : CategoryTheory.Category.{v', u'} J} →
{X : C} → [SizeOf C] → [(a : C) → SizeOf (P a)] → [SizeOf J] → P.ColimitOfShape J X → ℕ | null | false |
Lean.Lsp.FoldingRangeParams.mk.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | ∀ (textDocument : Lean.Lsp.TextDocumentIdentifier), sizeOf { textDocument := textDocument } = 1 + sizeOf textDocument | null | true |
mul_self_nonneg | Mathlib.Algebra.Order.Ring.Unbundled.Basic | ∀ {R : Type u} [inst : Semiring R] [inst_1 : LinearOrder R] [ExistsAddOfLE R] [PosMulMono R] [AddLeftMono R] (a : R),
0 ≤ a * a | null | true |
Matroid.comap_isBasis'_iff._simp_1 | Mathlib.Combinatorics.Matroid.Map | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {N : Matroid β} {I X : Set α},
(N.comap f).IsBasis' I X = (N.IsBasis' (f '' I) (f '' X) ∧ Set.InjOn f I ∧ I ⊆ X) | null | false |
AlexDisc.delabOf | Mathlib.Topology.Order.Category.AlexDisc | Lean.PrettyPrinter.Delaborator.Delab | This prints `AlexDisc.of X` as `↧X`. | true |
_private.Init.Data.Order.PackageFactories.0.Std.LinearPreorderPackage.ofOrd._simp_4 | Init.Data.Order.PackageFactories | ∀ {α : Type u} [inst : Ord α] [inst_1 : LE α] [Std.LawfulOrderOrd α] {a b : α}, ((compare a b).isGE = true) = (b ≤ a) | null | false |
CategoryTheory.IsoCat.noConfusion | Mathlib.CategoryTheory.IsoCat | {P : Sort u} →
{C : Type u_1} →
{D : Type u_2} →
{inst : CategoryTheory.Category.{v_1, u_1} C} →
{inst_1 : CategoryTheory.Category.{v_2, u_2} D} →
{t : CategoryTheory.IsoCat C D} →
{C' : Type u_1} →
{D' : Type u_2} →
{inst' : CategoryTheory.Categor... | null | false |
Ordinal.deriv_zero_left | Mathlib.SetTheory.Ordinal.FixedPoint | ∀ (a : Ordinal.{u_1}), Ordinal.deriv 0 a = a | null | true |
Lean.Order.le_iff_meet_eq_left | Std.Internal.Order.Lemmas | ∀ {l : Type uₗ} [inst : Lean.Order.CompleteLattice l] {P Q : l},
Lean.Order.PartialOrder.rel P Q ↔ Lean.Order.meet P Q = P | null | true |
SimpleGraph.completeEquipartiteGraph.completeMultipartiteGraph._proof_1 | Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | ∀ {r t : ℕ} {a b : Fin r × Fin t},
(SimpleGraph.completeMultipartiteGraph (Function.const (Fin r) (Fin t))).Adj
((Equiv.sigmaEquivProd (Fin r) (Fin t)).symm a) ((Equiv.sigmaEquivProd (Fin r) (Fin t)).symm b) ↔
(SimpleGraph.completeEquipartiteGraph r t).Adj a b | null | false |
Lean.Grind.Linarith.lt_norm | Init.Grind.Ordered.Linarith | ∀ {α : Type u_1} [inst : Lean.Grind.IntModule α] [inst_1 : LE α] [inst_2 : LT α] [Std.LawfulOrderLT α]
[inst_4 : Std.IsPreorder α] [Lean.Grind.OrderedAdd α] (ctx : Lean.Grind.Linarith.Context α)
(lhs rhs : Lean.Grind.Linarith.Expr) (p : Lean.Grind.Linarith.Poly),
Lean.Grind.Linarith.norm_cert lhs rhs p = true →
... | null | true |
DomMulAct.instCancelCommMonoidOfMulOpposite.eq_1 | Mathlib.GroupTheory.GroupAction.DomAct.Basic | ∀ {M : Type u_1} [inst : CancelCommMonoid Mᵐᵒᵖ], DomMulAct.instCancelCommMonoidOfMulOpposite = inst | null | true |
instRingFreeRing._proof_31 | Mathlib.RingTheory.FreeRing | ∀ (α : Type u_1), autoParam (∀ (n : ℕ), ↑(n + 1) = ↑n + 1) AddMonoidWithOne.natCast_succ._autoParam | null | false |
Lean.Grind.CommRing.Poly.degree | Lean.Meta.Sym.Arith.Poly | Lean.Grind.CommRing.Poly → ℕ | null | true |
SSet.horn.IsCompatible.δ_pred_comp._auto_1 | Mathlib.AlgebraicTopology.SimplicialSet.HornColimits | Lean.Syntax | null | false |
RBTree.RBNode.Slow.instDecidableMemP | Batteries.Recycling.RBTree.Basic | {α : Type u_1} → {cut : α → Ordering} → {t : RBTree.RBNode α} → Decidable (RBTree.RBNode.MemP cut t) | null | true |
SimpleGraph.Copy.isoSubgraphMap._simp_3 | Mathlib.Combinatorics.SimpleGraph.Copy | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∃ a, p a ∧ a = a') = p a' | null | false |
Pi.addHom.eq_1 | Mathlib.Algebra.Group.Pi.Lemmas | @Pi.addHom = @AddHom.pi | null | true |
Qq.Impl.unquoteExpr | Qq.Macro | Lean.Expr → Qq.Impl.UnquoteM Lean.Expr | null | true |
_private.Mathlib.RingTheory.Valuation.Extension.0.Valuation.HasExtension.algebraMap_mem_maximalIdeal_iff._simp_1_1 | Mathlib.RingTheory.Valuation.Extension | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : IsLocalRing R] (x : R),
(x ∈ IsLocalRing.maximalIdeal R) = (x ∈ nonunits R) | null | false |
Lean.Compiler.LCNF.ConfigOptions.mk | Lean.Compiler.LCNF.ConfigOptions | ℕ → ℕ → ℕ → Bool → Bool → ℕ → Bool → Lean.Compiler.LCNF.ConfigOptions | null | true |
_private.Lean.Meta.Tactic.Grind.Parser.0.Lean.Parser.Command.grindPattern._regBuiltin.Lean.Parser.Command.grindPatternCnstrs.parenthesizer_123 | Lean.Meta.Tactic.Grind.Parser | IO Unit | null | false |
_private.Mathlib.Topology.Algebra.Module.LinearPMap.0.LinearPMap.inverse_isClosable_iff.match_1_1 | Mathlib.Topology.Algebra.Module.LinearPMap | ∀ {R : Type u_1} {E : Type u_3} {F : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup E] [inst_2 : AddCommGroup F]
[inst_3 : Module R E] [inst_4 : Module R F] [inst_5 : TopologicalSpace E] [inst_6 : TopologicalSpace F]
{f : E →ₗ.[R] F} [inst_7 : ContinuousAdd E] [inst_8 : ContinuousAdd F] [inst_9 : TopologicalS... | null | false |
ne_zero_of_dvd_ne_zero | Mathlib.Algebra.GroupWithZero.Divisibility | ∀ {α : Type u_1} [inst : MonoidWithZero α] {p q : α}, q ≠ 0 → p ∣ q → p ≠ 0 | null | true |
_private.Mathlib.Data.Ordmap.Invariants.0.Ordnode.splitMax_eq.match_1_1 | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} (motive : ℕ → Ordnode α → α → Ordnode α → Prop) (x : ℕ) (x_1 : Ordnode α) (x_2 : α) (x_3 : Ordnode α),
(∀ (x : ℕ) (x_4 : Ordnode α) (x_5 : α), motive x x_4 x_5 Ordnode.nil) →
(∀ (x : ℕ) (l : Ordnode α) (x_4 : α) (ls : ℕ) (ll : Ordnode α) (lx : α) (lr : Ordnode α),
motive x l x_4 (Ordnode.... | null | false |
Lean.Meta.Canonicalizer.CanonM.run' | Lean.Meta.Canonicalizer | {α : Type} →
Lean.Meta.CanonM α →
optParam Lean.Meta.TransparencyMode Lean.Meta.TransparencyMode.instances →
optParam Lean.Meta.Canonicalizer.State { } → Lean.MetaM α | The definitionally equality tests are performed using the given transparency mode.
We claim `TransparencyMode.instances` is a good setting for most applications.
| true |
LinearMap.BilinForm.Isometry.mk | Mathlib.LinearAlgebra.BilinearForm.Isometry | {R : Type u_1} →
{M₁ : Type u_3} →
{M₂ : Type u_4} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M₁] →
[inst_2 : AddCommMonoid M₂] →
[inst_3 : Module R M₁] →
[inst_4 : Module R M₂] →
{B₁ : LinearMap.BilinForm R M₁} →
{B₂ : L... | null | true |
SSet.Edge.CompStruct.toSubcomplex | Mathlib.AlgebraicTopology.SimplicialSet.CompStruct | {X : SSet} →
{x₀ x₁ x₂ : X.obj (Opposite.op { len := 0 })} →
{e₀₁ : SSet.Edge x₀ x₁} →
{e₁₂ : SSet.Edge x₁ x₂} →
{e₀₂ : SSet.Edge x₀ x₂} →
(h : e₀₁.CompStruct e₁₂ e₀₂) →
(A : X.Subcomplex) →
(mem : h.simplex ∈ A.obj (Opposite.op { len := 2 })) →
(e... | When the underlying simplex of a `CompStruct` belongs to a subcomplex,
this is the induced `CompStruct` for the corresponding edges of the subcomplex. | true |
Mathlib.Tactic.RingNF._aux_Mathlib_Tactic_Ring_RingNF___macroRules_Mathlib_Tactic_RingNF_ring_1 | Mathlib.Tactic.Ring.RingNF | Lean.Macro | `ring` solves equations in *commutative* (semi)rings, allowing for variables in the
exponent. If the goal is not appropriate for `ring` (e.g. not an equality) `ring_nf` will be
suggested. See also `ring1`, which fails if the goal is not an equality.
* `ring!` will use a more aggressive reducibility setting to determin... | false |
AlgebraicGeometry.instQuasiCompactLiftSchemeIdOfQuasiSeparatedSpaceCarrierCarrierCommRingCat | Mathlib.AlgebraicGeometry.Morphisms.QuasiSeparated | ∀ {X : AlgebraicGeometry.Scheme} [QuasiSeparatedSpace ↥X],
AlgebraicGeometry.QuasiCompact
(CategoryTheory.Limits.prod.lift (CategoryTheory.CategoryStruct.id X) (CategoryTheory.CategoryStruct.id X)) | null | true |
Pi.subtractionMonoid.eq_1 | Mathlib.Algebra.Group.Pi.Basic | ∀ {I : Type u} {f : I → Type v₁} [inst : (i : I) → SubtractionMonoid (f i)],
Pi.subtractionMonoid = { toSubNegMonoid := Pi.subNegMonoid, neg_neg := ⋯, neg_add_rev := ⋯, neg_eq_of_add := ⋯ } | null | true |
CategoryTheory.regularEpiOfEpi | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X Y : C} →
[CategoryTheory.IsRegularEpiCategory C] → (f : X ⟶ Y) → [CategoryTheory.Epi f] → CategoryTheory.RegularEpi f | In a category in which every epimorphism is regular, we can express every epimorphism as
a coequalizer. This is not an instance because it would create an instance loop. | true |
AddAction.toAddSemigroupAction | Mathlib.Algebra.Group.Action.Defs | {G : Type u_9} → {P : Type u_10} → {inst : AddMonoid G} → [self : AddAction G P] → AddSemigroupAction G P | null | true |
SimpContFract.IsContFract | Mathlib.Algebra.ContinuedFractions.Basic | {α : Type u_1} → [inst : One α] → [Zero α] → [LT α] → SimpContFract α → Prop | A simple continued fraction is a *(regular) continued fraction* ((r)cf) if all partial denominators
`bᵢ` are positive, i.e. `0 < bᵢ`.
| true |
SimpleGraph.chromaticNumber_eq_iInf | Mathlib.Combinatorics.SimpleGraph.Coloring.Vertex | ∀ {V : Type u} (G : SimpleGraph V), G.chromaticNumber = ⨅ n, ↑↑n | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.0.Int64.reduceBEq._regBuiltin.Int64.reduceBEq.declare_2._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.922157756._hygCtx._hyg.9 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit | null | false |
AbstractMeasure.convolveFunRight_apply._proof_1 | Mathlib.NumberTheory.Padics.Measure.Monoid | ∀ {G : Type u_1} {R : Type u_2} [inst : TopologicalSpace G] [inst_1 : TopologicalSpace R] [inst_2 : Monoid G]
[ContinuousMul G] (f : C(G, R)) (x : G), Continuous fun y => f (x * y) | null | false |
Mathlib.Meta.FunProp.LambdaTheorem.getProof | Mathlib.Tactic.FunProp.Theorems | Mathlib.Meta.FunProp.LambdaTheorem → Lean.MetaM Lean.Expr | Return proof of lambda theorem | true |
_private.Mathlib.Algebra.Group.Conj.0.isConj_iff_eq.match_1_1 | Mathlib.Algebra.Group.Conj | ∀ {α : Type u_1} [inst : CommMonoid α] {a b : α} (motive : IsConj a b → Prop) (x : IsConj a b),
(∀ (c : αˣ) (hc : SemiconjBy (↑c) a b), motive ⋯) → motive x | null | false |
TopCat.pullbackHomeoPreimage._proof_7 | Mathlib.Topology.Category.TopCat.Limits.Pullbacks | ∀ {X : Type u_2} {Y : Type u_3} {Z : Type u_1} (f : X → Z) (g : Y → Z) (x : ↑(f ⁻¹' Set.range g)),
f ↑x = g (Exists.choose ⋯) | null | false |
GaloisInsertion.mk._flat_ctor | Mathlib.Order.GaloisConnection.Defs | {α : Type u_1} →
{β : Type u_2} →
[inst : Preorder α] →
[inst_1 : Preorder β] →
{l : α → β} →
{u : β → α} →
(choice : (x : α) → u (l x) ≤ x → β) →
GaloisConnection l u →
(∀ (x : β), x ≤ l (u x)) → (∀ (a : α) (h : u (l a) ≤ a), choice a h = l a) → G... | null | false |
_private.Mathlib.Analysis.BoxIntegral.Partition.Basic.0.BoxIntegral.Prepartition.filter_le.match_1_1 | Mathlib.Analysis.BoxIntegral.Partition.Basic | ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} (π : BoxIntegral.Prepartition I) (p : BoxIntegral.Box ι → Prop)
(J : BoxIntegral.Box ι) (motive : J ∈ π ∧ p J → Prop) (x : J ∈ π ∧ p J),
(∀ (hπ : J ∈ π) (right : p J), motive ⋯) → motive x | null | false |
Finset.shadow_mono | Mathlib.Combinatorics.SetFamily.Shadow | ∀ {α : Type u_1} [inst : DecidableEq α] {𝒜 ℬ : Finset (Finset α)}, 𝒜 ⊆ ℬ → 𝒜.shadow ⊆ ℬ.shadow | null | true |
_private.Mathlib.Topology.Algebra.Affine.0.AffineMap.isOpenEmbedding_linear_iff._simp_1_2 | Mathlib.Topology.Algebra.Affine | ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] (e : X ≃ₜ Y) {f : Y → Z}, Topology.IsOpenEmbedding (f ∘ ⇑e) = Topology.IsOpenEmbedding f | null | false |
AlgebraicGeometry.Scheme.canonicallyOverPullback | Mathlib.AlgebraicGeometry.Pullbacks | {M S T : AlgebraicGeometry.Scheme} →
[inst : M.Over S] → {f : T ⟶ S} → (CategoryTheory.Limits.pullback (M ↘ S) f).CanonicallyOver T | null | true |
_private.Lean.Meta.Tactic.Grind.MarkNestedSubsingletons.0.Lean.Meta.Grind.ProofOrDecidableResult.noConfusion | Lean.Meta.Tactic.Grind.MarkNestedSubsingletons | {P : Sort u} →
{t t' : Lean.Meta.Grind.ProofOrDecidableResult✝} →
t = t' → Lean.Meta.Grind.ProofOrDecidableResult.noConfusionType✝ P t t' | null | false |
LinearMap.FiniteRangeSetoid.equiv_comp_right | Mathlib.Algebra.Module.LinearMap.FiniteRange | ∀ {K : Type u_1} {V : Type u_2} {V₂ : Type u_3} {V₃ : Type u_4} [inst : CommRing K] [inst_1 : AddCommGroup V]
[inst_2 : Module K V] [inst_3 : AddCommGroup V₂] [inst_4 : Module K V₂] [inst_5 : AddCommGroup V₃]
[inst_6 : Module K V₃] {u : V →ₗ[K] V₂} {v v' : V₂ →ₗ[K] V₃}, v ≈ v' → v ∘ₗ u ≈ v' ∘ₗ u | null | true |
CategoryTheory.Abelian.Preradical.ι_π | Mathlib.CategoryTheory.Abelian.Preradical.Colon | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(Φ : CategoryTheory.Abelian.Preradical C), CategoryTheory.CategoryStruct.comp Φ.ι Φ.π = 0 | null | true |
_private.Plausible.Testable.0.Plausible.Decorations._aux_Plausible_Testable___elabRules_Plausible_Decorations_tacticMk_decorations_1.match_1 | Plausible.Testable | (motive : Lean.Expr → Sort u_1) →
(goalType : Lean.Expr) →
((us : List Lean.Level) →
(body : Lean.Expr) → motive ((Lean.Expr.const `Plausible.Decorations.DecorationsOf us).app body)) →
((x : Lean.Expr) → motive x) → motive goalType | null | false |
Int32.ofIntLE_le_iff_le | Init.Data.SInt.Lemmas | ∀ {a b : ℤ} (ha₁ : Int32.minValue.toInt ≤ a) (ha₂ : a ≤ Int32.maxValue.toInt) (hb₁ : Int32.minValue.toInt ≤ b)
(hb₂ : b ≤ Int32.maxValue.toInt), Int32.ofIntLE a ha₁ ha₂ ≤ Int32.ofIntLE b hb₁ hb₂ ↔ a ≤ b | null | true |
Std.DTreeMap.Internal.Impl.Const.getD_diff_of_contains_eq_false_left | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α]
(h₁ : m₁.WF),
m₂.WF →
∀ {k : α} {fallback : β},
Std.DTreeMap.Internal.Impl.contains k m₁ = false →
Std.DTreeMap.Internal.Impl.Const.getD (m₁.diff m₂ ⋯) k fallback = fallback | null | true |
LieEquiv.map_lie | Mathlib.Algebra.Lie.Basic | ∀ {R : Type u} {L₁ : Type v} {L₂ : Type w} [inst : CommRing R] [inst_1 : LieRing L₁] [inst_2 : LieRing L₂]
[inst_3 : LieAlgebra R L₁] [inst_4 : LieAlgebra R L₂] (e : L₁ ≃ₗ⁅R⁆ L₂) (x y : L₁), e ⁅x, y⁆ = ⁅e x, e y⁆ | null | true |
Std.DTreeMap.Internal.Impl.getKeyD_filter_key | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α] {f : α → Bool}
{k fallback : α} (h : t.WF),
(Std.DTreeMap.Internal.Impl.filter (fun k x => f k) t ⋯).impl.getKeyD k fallback =
(Option.filter f (t.getKey? k)).getD fallback | null | true |
Dyadic.neg.eq_1 | Init.Data.Dyadic.Basic | Dyadic.zero.neg = Dyadic.zero | null | true |
CategoryTheory.Limits.Fan.IsLimit.mk.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {β : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {f : β → C} (t : CategoryTheory.Limits.Fan f)
(lift : (s : CategoryTheory.Limits.Fan f) → s.pt ⟶ t.pt)
(fac : ∀ (s : CategoryTheory.Limits.Fan f) (j : β), CategoryTheory.CategoryStruct.comp (lift s) (t.proj j) = s.proj j)
(uniq :
∀ (s : Cat... | null | true |
Lean.PrettyPrinter.Formatter.Context.mk.inj | Lean.PrettyPrinter.Formatter | ∀ {options : Lean.Options} {table : Lean.Parser.TokenTable} {options_1 : Lean.Options}
{table_1 : Lean.Parser.TokenTable},
{ options := options, table := table } = { options := options_1, table := table_1 } →
options = options_1 ∧ table = table_1 | null | true |
AddAction.vadd_mem_of_set_mem_fixedBy | Mathlib.GroupTheory.GroupAction.FixedPoints | ∀ {α : Type u_1} {G : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G α] {s : Set α} {g : G},
s ∈ AddAction.fixedBy (Set α) g → ∀ {x : α}, g +ᵥ x ∈ s ↔ x ∈ s | null | true |
Set.unitEquivUnitsInteger._proof_3 | Mathlib.RingTheory.DedekindDomain.SInteger | ∀ {R : Type u_2} [inst : CommRing R] [inst_1 : IsDedekindDomain R] (S : Set (IsDedekindDomain.HeightOneSpectrum R))
(K : Type u_1) [inst_2 : Field K] [inst_3 : Algebra R K] [inst_4 : IsFractionRing R K],
Function.RightInverse (fun x => ⟨Units.mk0 ↑↑x ⋯, ⋯⟩) fun x =>
{ val := ⟨↑↑x, ⋯⟩, inv := ⟨↑(↑x)⁻¹, ⋯⟩, val_i... | null | false |
Lean.Lsp.instToJsonCodeActionClientCapabilities | Lean.Data.Lsp.CodeActions | Lean.ToJson Lean.Lsp.CodeActionClientCapabilities | null | true |
ciSup_eq_top_of_top_mem | Mathlib.Order.ConditionallyCompleteLattice.Indexed | ∀ {α : Type u_1} {ι : Sort u_4} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : OrderTop α] {f : ι → α},
⊤ ∈ Set.range f → iSup f = ⊤ | null | true |
_private.Mathlib.CategoryTheory.Triangulated.Opposite.OpOp.0.CategoryTheory.Pretriangulated.instIsTriangulatedOppositeOpOp._proof_2 | Mathlib.CategoryTheory.Triangulated.Opposite.OpOp | 1 + -1 = 0 | null | false |
UInt8.or_eq_zero_iff._simp_1 | Init.Data.UInt.Bitwise | ∀ {a b : UInt8}, (a ||| b = 0) = (a = 0 ∧ b = 0) | null | false |
Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.combineDivCoeffs.inj | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ {c₁ c₂ : Lean.Meta.Grind.Arith.Cutsat.LeCnstr} {k : ℤ} {c₁_1 c₂_1 : Lean.Meta.Grind.Arith.Cutsat.LeCnstr} {k_1 : ℤ},
Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.combineDivCoeffs c₁ c₂ k =
Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.combineDivCoeffs c₁_1 c₂_1 k_1 →
c₁ = c₁_1 ∧ c₂ = c₂_1 ∧ k = k_1 | null | true |
CategoryTheory.preserves_mono_of_preservesLimit | Mathlib.CategoryTheory.Limits.Constructions.EpiMono | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) {X Y : C} (f : X ⟶ Y)
[CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f f) F] [CategoryTheory.Mono f],
CategoryTheory.Mono (F.map f) | If `F` preserves pullbacks, then it preserves monomorphisms. | true |
Finpartition.part | Mathlib.Order.Partition.Finpartition | {α : Type u_1} → [inst : DecidableEq α] → {s : Finset α} → Finpartition s → α → Finset α | The part of the finpartition that `a` lies in. | true |
MeasureTheory.Lp.ext_iff | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_1} {E : Type u_4} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] {f g : ↥(MeasureTheory.Lp E p μ)}, f = g ↔ ↑↑f =ᵐ[μ] ↑↑g | null | true |
LinearMap.coprod_comp_inl_inr | Mathlib.LinearAlgebra.Prod | ∀ {R : Type u} {M : Type v} {M₂ : Type w} {M₃ : Type y} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M₂] [inst_3 : AddCommMonoid M₃] [inst_4 : Module R M] [inst_5 : Module R M₂]
[inst_6 : Module R M₃] (f : M × M₂ →ₗ[R] M₃), (f ∘ₗ LinearMap.inl R M M₂).coprod (f ∘ₗ LinearMap.inr R M M₂) = f | null | true |
Std.DHashMap.Internal.Raw.fold_cons_key | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} {l : Std.DHashMap.Raw α β} {acc : List α},
Std.DHashMap.Raw.fold (fun acc k x => k :: acc) acc l =
Std.Internal.List.keys (Std.DHashMap.Internal.toListModel l.buckets).reverse ++ acc | null | true |
_private.Mathlib.Util.FormatTable.0.formatTable.match_1 | Mathlib.Util.FormatTable | (motive : ℕ → Alignment → Sort u_1) →
(w : ℕ) →
(a : Alignment) →
((x : Alignment) → motive 0 x) →
((x : Alignment) → motive 1 x) →
((n : ℕ) → motive n.succ.succ Alignment.left) →
((n : ℕ) → motive n.succ.succ Alignment.right) →
((n : ℕ) → motive n.succ.succ Align... | null | false |
AddCon.coe_iInf._simp_1 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Add M] {ι : Sort u_4} (f : ι → AddCon M), ⨅ i, ⇑(f i) = ⇑(iInf f) | null | false |
Nat.addUnits_eq_zero | Mathlib.Algebra.Group.Nat.Units | ∀ (u : AddUnits ℕ), u = 0 | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.