name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Int16.toNatClampNeg | Init.Data.SInt.Basic | Int16 → ℕ | Converts a 16-bit signed integer to a natural number, mapping all negative numbers to `0`.
Use `Int16.toBitVec` to obtain the two's complement representation.
| true |
_private.Mathlib.Algebra.GroupWithZero.NonZeroDivisors.0.mk_mem_nonZeroDivisors_associates.match_1_1 | Mathlib.Algebra.GroupWithZero.NonZeroDivisors | ∀ {M₀ : Type u_1} [inst : CommMonoidWithZero M₀] {a : M₀} (motive : (∃ x, x * a = 0 ∧ x ≠ 0) → Prop)
(x : ∃ x, x * a = 0 ∧ x ≠ 0), (∀ (b : M₀) (hb₁ : b * a = 0) (hb₂ : b ≠ 0), motive ⋯) → motive x | null | false |
Lean.Compiler.LCNF.FindUsed.Context._sizeOf_inst | Lean.Compiler.LCNF.ReduceArity | SizeOf Lean.Compiler.LCNF.FindUsed.Context | null | false |
AddCommGrpCat.toCommGrp | Mathlib.Algebra.Category.Grp.EquivalenceGroupAddGroup | CategoryTheory.Functor AddCommGrpCat CommGrpCat | The functor `AddCommGrpCat ⥤ CommGrpCat` by sending `X ↦ Multiplicative X` and `f ↦ f`.
| true |
PseudoEMetricSpace.ofRiemannianMetric._proof_1 | Mathlib.Geometry.Manifold.Riemannian.Basic | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type u_2} [inst_2 : TopologicalSpace H]
(I : ModelWithCorners ℝ E H) (M : Type u_3) [inst_3 : TopologicalSpace M] [inst_4 : ChartedSpace H M] (_x : M),
IsTopologicalAddGroup (TangentSpace I _x) | null | false |
SimpleGraph.edge_le | Mathlib.Combinatorics.SimpleGraph.Operations | ∀ {V : Type u_1} (G : SimpleGraph V) (s t : V), SimpleGraph.edge s t ≤ G ↔ {s(s, t)} \ Sym2.diagSet ⊆ G.edgeSet | null | true |
Lean.JsonRpc.ResponseError.message | Lean.Data.JsonRpc | {α : Type u} → Lean.JsonRpc.ResponseError α → String | A string providing a short description of the error. | true |
Complex.cos_sub_pi_div_two | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℂ), Complex.cos (x - ↑Real.pi / 2) = Complex.sin x | null | true |
_private.Batteries.Data.PairingHeap.0.Batteries.PairingHeap.tail?.match_1 | Batteries.Data.PairingHeap | {α : Type u_1} →
(motive : Option (Batteries.PairingHeapImp.Heap α) → Sort u_2) →
(x : Option (Batteries.PairingHeapImp.Heap α)) →
(x = none → motive none) → ((tl : Batteries.PairingHeapImp.Heap α) → x = some tl → motive (some tl)) → motive x | null | false |
TopologicalSpace.Compacts.topology | Mathlib.Topology.Sets.VietorisTopology | {α : Type u_1} → [inst : TopologicalSpace α] → TopologicalSpace (TopologicalSpace.Compacts α) | The Vietoris topology on the compact subsets of a topological space. | true |
_private.Mathlib.MeasureTheory.MeasurableSpace.Invariants.0.MeasurableSpace.measurable_invariants_dom._simp_1_2 | Mathlib.MeasureTheory.MeasurableSpace.Invariants | ∀ {α : Sort u_1} {p q : α → Prop}, ((∀ (x : α), p x) ∧ ∀ (x : α), q x) = ∀ (x : α), p x ∧ q x | null | false |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.FinalizeContext.mk.inj | Lean.Elab.MutualInductive | ∀ {elabs : Array Lean.Elab.Command.InductiveElabStep2} {mctx : Lean.MetavarContext} {levelParams : List Lean.Name}
{params : Array Lean.Expr} {lctx : Lean.LocalContext} {localInsts : Lean.LocalInstances}
{replaceIndFVars : Lean.Expr → Lean.MetaM Lean.Expr} {elabs_1 : Array Lean.Elab.Command.InductiveElabStep2}
{m... | null | true |
String.sliceFrom.eq_1 | Init.Data.String.Basic | ∀ (s : String) (p : s.Pos), s.sliceFrom p = s.toSlice.sliceFrom p.toSlice | null | true |
_private.Mathlib.Data.Int.Interval.0.Finset.Ioo_succ_succ._simp_1_1 | Mathlib.Data.Int.Interval | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α}, (x ∈ Finset.Ioo a b) = (a < x ∧ x < b) | null | false |
CategoryTheory.Functor.mapConeMapConeInv | Mathlib.CategoryTheory.Limits.Cones | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
{D : Type u₄} →
[inst_2 : CategoryTheory.Category.{v₄, u₄} D] →
{F : CategoryTheory.Functor J D} →
(H : CategoryTheory.Functor D C) →
... | `mapCone` is the left inverse to `mapConeInv`. | true |
Descriptive.Tree.tree_eq_bot._simp_1 | Mathlib.SetTheory.Descriptive.Tree | ∀ {A : Type u_1} {T : ↥(Descriptive.tree A)}, (T = ⊥) = ([] ∉ T) | null | false |
Convexity.StdSimplex.rec | Mathlib.Geometry.Convex.ConvexSpace.Defs | {R : Type u} →
[inst : LE R] →
[inst_1 : AddCommMonoid R] →
[inst_2 : One R] →
{X : Type v} →
{motive : Convexity.StdSimplex R X → Sort u_1} →
((weights : X →₀ R) →
(nonneg : 0 ≤ weights) →
(total : (weights.sum fun x r => r) = 1) →
... | null | false |
_private.Init.Data.List.MapIdx.0.List.exists_of_mem_mapFinIdx._simp_1_2 | Init.Data.List.MapIdx | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∃ x, q x) = ∃ a, ∃ (b : p a), q ⟨a, b⟩ | null | false |
ContinuousAddMonoidHom.rec | Mathlib.Topology.Algebra.ContinuousMonoidHom | {A : Type u_7} →
{B : Type u_8} →
[inst : AddMonoid A] →
[inst_1 : AddMonoid B] →
[inst_2 : TopologicalSpace A] →
[inst_3 : TopologicalSpace B] →
{motive : (A →ₜ+ B) → Sort u} →
((toAddMonoidHom : A →+ B) →
(continuous_toFun : Continuous (↑toAddM... | null | false |
AddSubgroup.relIndex_comap | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} {G' : Type u_2} [inst : AddGroup G] [inst_1 : AddGroup G'] (H : AddSubgroup G) (f : G' →+ G)
(K : AddSubgroup G'), (AddSubgroup.comap f H).relIndex K = H.relIndex (AddSubgroup.map f K) | null | true |
List.subperm.cons | Mathlib.Data.List.Perm.Subperm | ∀ {α : Type u_1} (a : α) {l₁ l₂ : List α}, l₁.Subperm l₂ → (a :: l₁).Subperm (a :: l₂) | **Alias** of the reverse direction of `List.subperm_cons`. | true |
OpenAddSubgroup.toOpens_inf._simp_1 | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] {U V : OpenAddSubgroup G}, ↑U ⊓ ↑V = ↑(U ⊓ V) | null | false |
Filter.tendsto_mul_self_atTop | Mathlib.Order.Filter.AtTopBot.Ring | ∀ {α : Type u_1} [inst : Semiring α] [inst_1 : PartialOrder α] [IsOrderedRing α],
Filter.Tendsto (fun x => x * x) Filter.atTop Filter.atTop | null | true |
WeierstrassCurve.twoTorsionPolynomial.eq_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Weierstrass | ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R),
W.twoTorsionPolynomial = { a := 4, b := W.b₂, c := 2 * W.b₄, d := W.b₆ } | null | true |
_private.Mathlib.Order.Monotone.MonovaryOrder.0.instIsStrictTotalOrderMonovaryOrder._simp_4 | Mathlib.Order.Monotone.MonovaryOrder | ∀ {p q : Prop}, (p ↔ q ∧ p) = (p → q) | null | false |
IsLocalMinOn.hasFDerivWithinAt_nonneg | Mathlib.Analysis.Calculus.LocalExtr.Basic | ∀ {E : Type u} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : E → ℝ} {f' : StrongDual ℝ E} {s : Set E}
{a y : E}, IsLocalMinOn f s a → HasFDerivWithinAt f f' s a → y ∈ posTangentConeAt s a → 0 ≤ f' y | If `f` has a local min on `s` at `a`, `f'` is the derivative of `f` at `a` within `s`, and
`y` belongs to the positive tangent cone of `s` at `a`, then `0 ≤ f' y`. | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.Const.length_filter_key_eq_length_iff._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} {p : α → Bool}, List.filter p = List.filterMap (Option.guard fun x => p x) | null | false |
HasFiniteFPowerSeriesOnBall.continuousOn | Mathlib.Analysis.Analytic.CPolynomialDef | ∀ {𝕜 : 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] {f : E → F}
{p : FormalMultilinearSeries 𝕜 E F} {x : E} {r : ENNReal} {n : ℕ},
HasFiniteFPowerSeriesOnBall f ... | If a function admits a finite power series expansion on a disk, then it is continuous there. | true |
Int.zmultiples_natAbs | Mathlib.Algebra.Group.Subgroup.ZPowers.Basic | ∀ (a : ℤ), AddSubgroup.zmultiples ↑a.natAbs = AddSubgroup.zmultiples a | null | true |
MvPolynomial.isWeightedHomogeneous_zero | Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous | ∀ (R : Type u_1) {M : Type u_2} [inst : CommSemiring R] {σ : Type u_3} [inst_1 : AddCommMonoid M] (w : σ → M) (m : M),
MvPolynomial.IsWeightedHomogeneous w 0 m | 0 is weighted homogeneous of any degree. | true |
symmDiff_right_inj._simp_1 | Mathlib.Order.SymmDiff | ∀ {α : Type u_2} [inst : GeneralizedBooleanAlgebra α] {a b c : α}, (symmDiff a b = symmDiff a c) = (b = c) | null | false |
_private.Batteries.Tactic.GeneralizeProofs.0.Batteries.Tactic.GeneralizeProofs.MAbs.findProof?._sparseCasesOn_1 | Batteries.Tactic.GeneralizeProofs | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Part.some_dom._simp_1 | Mathlib.Data.Part | ∀ {α : Type u_1} (a : α), (Part.some a).1 = True | null | false |
CategoryTheory.HasProjectiveDimensionLT.recOn | Mathlib.CategoryTheory.Abelian.Projective.Dimension | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
{X : C} →
{n : ℕ} →
{motive : CategoryTheory.HasProjectiveDimensionLT X n → Sort u_1} →
(t : CategoryTheory.HasProjectiveDimensionLT X n) →
((subsingleton' : ∀ (i : ℕ)... | null | false |
Aesop.elabForwardRuleTerm | Aesop.Forward.Match | Lean.MVarId → Aesop.RuleTerm → Lean.MetaM Lean.Expr | Elaborate the term of a forward rule in the current goal. | true |
Lean.instBEqDeclaration | Lean.Declaration | BEq Lean.Declaration | null | true |
Stream'.Seq.append_nil | Mathlib.Data.Seq.Basic | ∀ {α : Type u} (s : Stream'.Seq α), s.append Stream'.Seq.nil = s | null | true |
MeasurableEquiv.refl_toEquiv | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ (α : Type u_6) [inst : MeasurableSpace α], (MeasurableEquiv.refl α).toEquiv = Equiv.refl α | null | true |
Polynomial.divModByMonicAux | Mathlib.Algebra.Polynomial.Div | {R : Type u} → [inst : Ring R] → Polynomial R → {q : Polynomial R} → q.Monic → Polynomial R × Polynomial R | See `divByMonic`. | true |
_private.Mathlib.Analysis.Distribution.TemperateGrowth.0.Function.hasTemperateGrowth_one_add_norm_sq_rpow._proof_1_2 | Mathlib.Analysis.Distribution.TemperateGrowth | (2 + 1).AtLeastTwo | null | false |
DirSupInacc.of_isEmpty._simp_1 | Mathlib.Order.DirSupClosed | ∀ {α : Type u_1} [inst : Preorder α] [IsEmpty α] {s : Set α}, DirSupInacc s = True | null | false |
Lean.Parser.Tactic.MRefinePat._sizeOf_2_eq | Std.Tactic.Do.Syntax | ∀ (x : List Lean.Parser.Tactic.MRefinePat), Lean.Parser.Tactic.MRefinePat._sizeOf_2 x = sizeOf x | null | false |
_private.Mathlib.MeasureTheory.Covering.Differentiation.0.VitaliFamily.ae_eventually_measure_pos._simp_1_2 | Mathlib.MeasureTheory.Covering.Differentiation | ∀ {α : Type u} {p : α → Prop} {f : Filter α}, (¬∀ᶠ (x : α) in f, p x) = ∃ᶠ (x : α) in f, ¬p x | null | false |
PowerSeries.IsWeierstrassDivisorAt.isWeierstrassDivisionAt_div_mod | Mathlib.RingTheory.PowerSeries.WeierstrassPreparation | ∀ {A : Type u_1} [inst : CommRing A] {g : PowerSeries A} {I : Ideal A} (H : g.IsWeierstrassDivisorAt I)
(f : PowerSeries A) [inst_1 : IsAdicComplete I A], f.IsWeierstrassDivisionAt g (H.div f) (H.mod f) I | If the ring is `I`-adic complete, then `g` can be used as a divisor in Weierstrass division. | true |
MvPowerSeries.LinearTopology.hasBasis_nhds_zero | Mathlib.RingTheory.MvPowerSeries.LinearTopology | ∀ {σ : Type u_1} {R : Type u_2} [inst : Ring R] [inst_1 : TopologicalSpace R] [IsLinearTopology R R]
[IsLinearTopology Rᵐᵒᵖ R],
(nhds 0).HasBasis (fun Id => ↑Id.1 ∈ nhds 0) fun Id => ↑(MvPowerSeries.LinearTopology.basis σ R Id) | If the ring `R` is endowed with a linear topology, then the sets `↑basis σ R (J, d)`,
for `J : TwoSidedIdeal R` which are neighborhoods of `0 : R` and `d : σ →₀ ℕ`,
constitute a basis of neighborhoods of `0 : MvPowerSeries σ R` for the product topology. | true |
_private.Init.Prelude.0.Nat.mod_lt.match_1_3 | Init.Prelude | ∀ (motive : ℕ → (x : ℕ) → 0 < x → Prop) (x x_1 : ℕ) (x_2 : 0 < x_1),
(∀ (n : ℕ) (x : 0 < n.succ), motive 0 n.succ x) → (∀ (n m : ℕ) (hm : 0 < m), motive n.succ m hm) → motive x x_1 x_2 | null | false |
ULift.down_sdiff | Mathlib.Order.ULift | ∀ {α : Type u} [inst : SDiff α] (a b : ULift.{u_1, u} α), (a \ b).down = a.down \ b.down | null | true |
AddCon.quotientKerEquivRange.match_1 | Mathlib.GroupTheory.Congruence.Basic | ∀ {M : Type u_2} {P : Type u_1} [inst : AddZeroClass M] [inst_1 : AddZeroClass P] (f : M →+ P)
(motive : ↥(AddMonoidHom.mrange (AddCon.kerLift f)) → Prop) (x : ↥(AddMonoidHom.mrange (AddCon.kerLift f))),
(∀ (w : P) (z : (AddCon.ker f).Quotient) (hz : (AddCon.kerLift f) z = w), motive ⟨w, ⋯⟩) → motive x | null | false |
AlgebraicGeometry.Scheme.instIsStableUnderCompositionProetalePrecoverage | Mathlib.AlgebraicGeometry.Sites.Proetale | AlgebraicGeometry.Scheme.proetalePrecoverage.IsStableUnderComposition | null | true |
Function.isPeriodicPt_minimalPeriod | Mathlib.Dynamics.PeriodicPts.Defs | ∀ {α : Type u_1} (f : α → α) (x : α), Function.IsPeriodicPt f (Function.minimalPeriod f x) x | null | true |
Qq.unpackParensIdent._unsafe_rec | Qq.Match | Lean.Syntax → Option Lean.Syntax | null | false |
PowerSeries.order_monomial | Mathlib.RingTheory.PowerSeries.Order | ∀ {R : Type u_1} [inst : Semiring R] (n : ℕ) (a : R) [inst_1 : Decidable (a = 0)],
((PowerSeries.monomial n) a).order = if a = 0 then ⊤ else ↑n | The order of the monomial `a*X^n` is infinite if `a = 0` and `n` otherwise. | true |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.add_one_tdiv_of_pos._proof_1_15 | Init.Data.Int.DivMod.Lemmas | ∀ {a : ℤ} {b : ℤ} (b : ℕ), ¬0 ≤ a + 1 → ¬a < 0 → False | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey!_inter._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
Real.pi_div_two_le_arcsin._simp_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse | ∀ {x : ℝ}, (Real.pi / 2 ≤ Real.arcsin x) = (1 ≤ x) | null | false |
instAlgebraPointedContMDiffMap._proof_6 | Mathlib.Geometry.Manifold.DerivationBundle | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] (I : ModelWithCorners 𝕜 E H) (M : Type u_4)
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] (n : WithTop ℕ∞) (x : M) (r : 𝕜)
(x_... | null | false |
ConvexCone.carrier | Mathlib.Geometry.Convex.Cone.Basic | {R : Type u_2} →
{M : Type u_4} →
[inst : Semiring R] →
[inst_1 : PartialOrder R] → [inst_2 : AddCommMonoid M] → [inst_3 : SMul R M] → ConvexCone R M → Set M | The **carrier set** underlying this cone: the set of points contained in it | true |
IsDenseInducing.tendsto_comap_nhds_nhds | Mathlib.Topology.DenseEmbedding | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
{i : α → β} [inst_2 : TopologicalSpace δ] {f : γ → α} {g : γ → δ} {h : δ → β} {d : δ} {a : α},
IsDenseInducing i →
Filter.Tendsto h (nhds d) (nhds (i a)) → h ∘ g = i ∘ f → Filter.Tendsto f (Fi... | ```
γ -f→ α
g↓ ↓e
δ -h→ β
```
| true |
Int64.lt_trans | Init.Data.SInt.Lemmas | ∀ {a b c : Int64}, a < b → b < c → a < c | null | true |
Aesop.SlotIndex.mk.sizeOf_spec | Aesop.Forward.SlotIndex | ∀ (toNat : ℕ), sizeOf { toNat := toNat } = 1 + sizeOf toNat | null | true |
integralClosure.coe_smul | Mathlib.RingTheory.IntegralClosure.Algebra.Basic | ∀ {G : Type u_1} {R : Type u_2} {K : Type u_3} [inst : CommRing R] [inst_1 : CommRing K] [inst_2 : Algebra R K]
[inst_3 : Group G] [inst_4 : MulSemiringAction G K] [inst_5 : SMulCommClass G R K] (g : G)
(k : ↥(integralClosure R K)), ↑(g • k) = g • ↑k | null | true |
CategoryTheory.Bicategory.postcomp | Mathlib.CategoryTheory.Bicategory.Basic | {B : Type u} →
[inst : CategoryTheory.Bicategory B] → {b c : B} → (a : B) → (b ⟶ c) → CategoryTheory.Functor (a ⟶ b) (a ⟶ c) | Postcomposition of a 1-morphism as a functor. | true |
Std.ExtDTreeMap.maxKey?_eq_some_iff_getKey?_eq_self_and_forall | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
{km : α}, t.maxKey? = some km ↔ t.getKey? km = some km ∧ ∀ k ∈ t, (cmp k km).isLE = true | null | true |
CategoryTheory.Limits.ChosenPullback.LiftStruct.f_p._autoParam | Mathlib.CategoryTheory.Limits.Shapes.Pullback.ChosenPullback | Lean.Syntax | null | false |
Module.basisOfFiniteTypeTorsionFree._proof_7 | Mathlib.LinearAlgebra.FreeModule.PID | ∀ {ι : Type u_2} {R : Type u_1} [inst : CommRing R] {M : Type u_3} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[IsDomain R] [inst_4 : Fintype ι] {s : ι → M}
(this : ∃ s_1, LinearIndepOn R s s_1 ∧ ∀ i ∉ s_1, ∃ a, a ≠ 0 ∧ a • s i ∈ Submodule.span R (s '' s_1)) (a : ι → R),
(∀ (i : ι), a i ≠ 0 ∧ a i • s i ∈ Subm... | null | false |
Metric.nhds_basis_closedEBall | Mathlib.Topology.EMetricSpace.Defs | ∀ {α : Type u_4} [inst : PseudoEMetricSpace α] {x : α}, (nhds x).HasBasis (fun ε => 0 < ε) (Metric.closedEBall x) | null | true |
LinearIndependent.group_smul | Mathlib.LinearAlgebra.LinearIndependent.Basic | ∀ {ι : Type u'} {R : Type u_2} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{G : Type u_6} [hG : Group G] [inst_3 : MulAction G R] [inst_4 : SMul G M] [IsScalarTower G R M] [SMulCommClass G R M]
{v : ι → M}, LinearIndependent R v → ∀ (w : ι → G), LinearIndependent R (w • v) | null | true |
mulRightEmbedding_apply | Mathlib.Algebra.Group.Embedding | ∀ {G : Type u_1} [inst : Mul G] [inst_1 : IsRightCancelMul G] (g h : G), (mulRightEmbedding g) h = h * g | null | true |
CategoryTheory.Localization.Construction.LocQuiver.mk.noConfusion | Mathlib.CategoryTheory.Localization.Construction | {C : Type uC} →
{inst : CategoryTheory.Category.{uC', uC} C} →
{W : CategoryTheory.MorphismProperty C} →
{P : Sort u} → {obj obj' : C} → { obj := obj } = { obj := obj' } → (obj ≍ obj' → P) → P | null | false |
Lean.ElabBlock.custom.injEq | Lean.DocString.Extension | ∀ (val val_1 : Dynamic), (Lean.ElabBlock.custom val = Lean.ElabBlock.custom val_1) = (val = val_1) | null | true |
ContinuousLinearMap.norm_single_le_one | Mathlib.Analysis.Normed.Operator.NormedSpace | ∀ {ι : Type u_9} [inst : Fintype ι] [inst_1 : DecidableEq ι] (𝕜 : Type u_10) [inst_2 : NontriviallyNormedField 𝕜]
(E : ι → Type u_11) [inst_3 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_4 : (i : ι) → NormedSpace 𝕜 (E i)]
(i : ι), ‖ContinuousLinearMap.single 𝕜 E i‖ ≤ 1 | null | true |
Lean.ParseImports.State.recOn | Lean.Elab.ParseImportsFast | {motive : Lean.ParseImports.State → Sort u} →
(t : Lean.ParseImports.State) →
((imports : Array Lean.Import) →
(pos : String.Pos.Raw) →
(badModifier : Bool) →
(error? : Option String) →
(isModule isMeta isExported importAll : Bool) →
motive
... | null | false |
CategoryTheory.Limits.IsColimit.ofCoconeEquiv_apply_desc | Mathlib.CategoryTheory.Limits.IsLimit | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} K]
{C : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor J C} {D : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} D] {G : CategoryTheory.Functor K D}
(h : Cat... | null | true |
_private.Mathlib.Topology.UniformSpace.Basic.0.UniformContinuousOn.comp._simp_1_3 | Mathlib.Topology.UniformSpace.Basic | ∀ {α : Type u} {a : Set α} {p : α → Prop}, (∀ᶠ (x : α) in Filter.principal a, p x) = ∀ x ∈ a, p x | null | false |
IsLocalizedModule.mk'_eq_zero._simp_1 | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Submonoid R} {M : Type u_2} {M' : Type u_3} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M'] [inst_3 : Module R M] [inst_4 : Module R M'] {f : M →ₗ[R] M'}
[inst_5 : IsLocalizedModule S f] {m : M} (s : ↥S), (IsLocalizedModule.mk' f m s = 0) = (f m = 0) | null | false |
Lean.Elab.Term.Quotation.precheckAttribute | Lean.Elab.Quotation.Precheck | Lean.KeyedDeclsAttribute Lean.Elab.Term.Quotation.Precheck | Registers a double backtick syntax quotation pre-check.
`@[quot_precheck k]` registers a declaration of type `Lean.Elab.Term.Quotation.Precheck` for the
syntax node kind `k`. It should implement eager name analysis on the passed syntax by throwing an
exception on unbound identifiers, and calling `precheck` recursively... | true |
_private.Mathlib.CategoryTheory.LocallyDirected.0.CategoryTheory.instIsLocallyDirectedWidePushoutShapeOfMonoObjNoneSomeMapInit._simp_2 | Mathlib.CategoryTheory.LocallyDirected | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∀ (a : α), a = a' → p a) = p a' | null | false |
AddSubmonoid.LocalizationMap.exists_of_eq | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [inst_1 : AddCommMonoid N]
(f : S.LocalizationMap N) {x y : M}, f x = f y → ∃ c, ↑c + x = ↑c + y | null | true |
_private.Mathlib.Algebra.Star.CHSH.0.tsirelson_inequality._proof_1_6 | Mathlib.Algebra.Star.CHSH | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : Algebra ℝ R] (A₀ A₁ B₀ B₁ : R),
A₁ * B₁ + (-(A₀ * B₀) + (-(A₀ * B₁) + (-(A₁ * B₀) + √2 ^ 3 • 1))) =
A₁ * B₁ + (-(A₀ * B₀) + (-(A₀ * B₁) + (-(A₁ * B₀) + (2 * (√2)⁻¹ + 4 * ((√2)⁻¹ * 2⁻¹)) • 1))) | null | false |
Polynomial.eval₂_map | Mathlib.Algebra.Polynomial.Eval.Coeff | ∀ {R : Type u} {S : Type v} {T : Type w} [inst : Semiring R] {p : Polynomial R} [inst_1 : Semiring S] (f : R →+* S)
[inst_2 : Semiring T] (g : S →+* T) (x : T),
Polynomial.eval₂ g x (Polynomial.map f p) = Polynomial.eval₂ (g.comp f) x p | null | true |
CategoryTheory.Limits.IsColimit.mk.sizeOf_spec | Mathlib.CategoryTheory.Limits.IsLimit | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} {t : CategoryTheory.Limits.Cocone F} [inst_2 : SizeOf J] [inst_3 : SizeOf C]
(desc : (s : CategoryTheory.Limits.Cocone F) → t.pt ⟶ s.pt)
(fac :
autoParam
... | null | true |
ContinuousLinearMap.restrictScalars_add | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.RestrictScalars | ∀ {A : Type u_1} {M₁ : Type u_2} {M₂ : Type u_3} {R : Type u_4} [inst : Semiring A] [inst_1 : Semiring R]
[inst_2 : AddCommMonoid M₁] [inst_3 : Module A M₁] [inst_4 : Module R M₁] [inst_5 : TopologicalSpace M₁]
[inst_6 : AddCommMonoid M₂] [inst_7 : Module A M₂] [inst_8 : Module R M₂] [inst_9 : TopologicalSpace M₂]
... | null | true |
CategoryTheory.Triangulated.AbelianSubcategory.ιK.congr_simp | Mathlib.CategoryTheory.Triangulated.TStructure.AbelianSubcategory | ∀ {C : Type u_1} {A : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.HasShift C ℤ]
[inst_2 : CategoryTheory.Category.{v_2, u_2} A] {ι : CategoryTheory.Functor A C} {X₁ : A} {X₃ : C}
(f₃ f₃_1 : X₃ ⟶ (CategoryTheory.shiftFunctor C 1).obj (ι.obj X₁)),
f₃ = f₃_1 →
∀ {K : A} (α α_... | null | true |
AlgebraicGeometry.StructureSheaf.isFractionPrelocal._proof_1 | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ (R M : Type u_1) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{U V : TopologicalSpace.Opens ↑(AlgebraicGeometry.PrimeSpectrum.Top R)} (i : U ⟶ V)
(f : (x : ↥V) → AlgebraicGeometry.StructureSheaf.Localizations M ↑x),
AlgebraicGeometry.StructureSheaf.IsFraction f → AlgebraicGeometry.Structu... | null | false |
Std.DHashMap.Internal.Raw₀.Const.getD_insertManyIfNewUnit_list | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] (m : Std.DHashMap.Internal.Raw₀ α fun x => Unit) {l : List α}
{k : α} {fallback : Unit},
Std.DHashMap.Internal.Raw₀.Const.getD (↑(Std.DHashMap.Internal.Raw₀.Const.insertManyIfNewUnit m l)) k fallback = () | null | true |
Matrix.blockDiagAddMonoidHom._proof_1 | Mathlib.Data.Matrix.Block | ∀ (m : Type u_2) (n : Type u_3) (o : Type u_4) (α : Type u_1) [inst : AddZeroClass α], Matrix.blockDiag 0 = 0 | null | false |
Std.TreeMap.isSome_minKey?_of_mem | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α},
k ∈ t → t.minKey?.isSome = true | null | true |
List.prev_getLast_cons' | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} [inst : DecidableEq α] (l : List α) (x y : α) (hxy : x ∈ y :: l),
x = y → (y :: l).prev x hxy = (y :: l).getLast ⋯ | null | true |
SimpleGraph.Adj.isPath_toWalk | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} (h : G.Adj u v), h.toWalk.IsPath | null | true |
Ioc_mem_nhdsLT_of_mem | Mathlib.Topology.Order.OrderClosed | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [ClosedIicTopology α] {a b c : α},
b ∈ Set.Ioc a c → Set.Ioc a c ∈ nhdsWithin b (Set.Iio b) | null | true |
Array.countP_set | Init.Data.Array.Count | ∀ {α : Type u_1} {p : α → Bool} {xs : Array α} {i : ℕ} {a : α} (h : i < xs.size),
Array.countP p (xs.set i a h) = (Array.countP p xs - if p xs[i] = true then 1 else 0) + if p a = true then 1 else 0 | null | true |
LieAlgebra.Basis.symm_f | Mathlib.Algebra.Lie.Basis.Basic | ∀ {ι : Type u_1} {R : Type u_2} {L : Type u_3} [inst : Finite ι] [inst_1 : CommRing R] [inst_2 : LieRing L]
[inst_3 : LieAlgebra R L] {H : LieSubalgebra R L} (b : LieAlgebra.Basis ι H), b.symm.f = b.e | null | true |
CategoryTheory.Limits.biprod.map_eq_map' | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{W X Y Z : C} [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct W X]
[inst_3 : CategoryTheory.Limits.HasBinaryBiproduct Y Z] (f : W ⟶ Y) (g : X ⟶ Z),
CategoryTheory.Limits.biprod.map f g = CategoryThe... | null | true |
Std.Time.Modifier.E.injEq | Std.Time.Format.Modifier | ∀ (presentation presentation_1 : Std.Time.Text),
(Std.Time.Modifier.E presentation = Std.Time.Modifier.E presentation_1) = (presentation = presentation_1) | null | true |
Representation.quotient._proof_2 | Mathlib.RepresentationTheory.Basic | ∀ {k : Type u_2} {G : Type u_3} {V : Type u_1} [inst : Ring k] [inst_1 : Monoid G] [inst_2 : AddCommGroup V]
[inst_3 : Module k V] (ρ : Representation k G V) (W : Submodule k V)
(le_comap : ∀ (g : G), W ≤ Submodule.comap (ρ g) W) (x x_1 : G),
W.mapQ W (ρ (x * x_1)) ⋯ = W.mapQ W (ρ x) ⋯ * W.mapQ W (ρ x_1) ⋯ | null | false |
Mathlib.Tactic.BicategoryLike.Normalize.Result._sizeOf_inst | Mathlib.Tactic.CategoryTheory.Coherence.PureCoherence | SizeOf Mathlib.Tactic.BicategoryLike.Normalize.Result | null | false |
Aesop.Frontend.TacticConfig.rec | Aesop.Frontend.Tactic | {motive : Aesop.Frontend.TacticConfig → Sort u} →
((additionalRules erasedRules : Array Aesop.Frontend.RuleExpr) →
(enabledRuleSets : Std.HashSet Aesop.RuleSetName) →
(options : Aesop.Options) →
(simpConfig : Lean.Meta.Simp.Config) →
(simpConfigSyntax? : Option Lean.Term) →
... | null | false |
SchwartzMap.toTemperedDistributionCLM._proof_3 | Mathlib.Analysis.Distribution.TemperedDistribution | ∀ (E : Type u_1) (F : Type u_2) [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℂ F] [inst_4 : MeasurableSpace E] [inst_5 : BorelSpace E] [inst_6 : SecondCountableTopology E]
(μ : MeasureTheory.Measure E) [hμ : μ.HasTemperateGrowth] (x x_1 : SchwartzMap... | null | false |
CategoryTheory.CartesianMonoidalCategory.whiskerLeft_fst | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C] (X : C)
{Y Z : C} (f : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerLeft X f)
(CategoryTheory.SemiCartesianMonoidalCategory.fst X Z) =
CategoryTheory.S... | null | true |
_private.Lean.Elab.ConfigEval.DeriveEvalTerm.0.Lean.Elab.ConfigEval.EvalTerm.resolveAtomicNameForConstNamespace.match_5 | Lean.Elab.ConfigEval.DeriveEvalTerm | (motive : Lean.Name → Sort u_1) →
(n : Lean.Name) → ((pre : Lean.Name) → (s : String) → motive (pre.str s)) → ((x : Lean.Name) → motive x) → motive n | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.