name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
TopRep.Hom.ext_iff | Mathlib.RepresentationTheory.Continuous.TopRep | ∀ {k : Type u} {G : Type v} {inst : TopologicalSpace k} {inst_1 : Ring k} {inst_2 : Monoid G} {A : TopRep k G}
{B : TopRep k G} {x y : A.Hom B}, x = y ↔ x.hom' = y.hom' | null | true |
Vector.toArray_swapIfInBounds | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {i j : ℕ}, (xs.swapIfInBounds i j).toArray = xs.toArray.swapIfInBounds i j | null | true |
LocallyConstant.congrLeftₗ_symm_apply_apply | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {Z : Type u_6} (R : Type u_7)
[inst_2 : Semiring R] [inst_3 : AddCommMonoid Z] [inst_4 : Module R Z] (e : X ≃ₜ Y) (a : LocallyConstant Y Z)
(a_1 : X), ((LocallyConstant.congrLeftₗ R e).symm a) a_1 = a (e a_1) | null | true |
SFinKer.Hom.noConfusion | Mathlib.Probability.Kernel.Category.SFinKer | {P : Sort u_1} →
{X Y : SFinKer} →
{t : X.Hom Y} → {X' Y' : SFinKer} → {t' : X'.Hom Y'} → X = X' → Y = Y' → t ≍ t' → SFinKer.Hom.noConfusionType P t t' | null | false |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.instIteratorIdSearchStep._simp_32 | Init.Data.String.Pattern.String | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
AddOpposite.instAddMonoid._proof_4 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : AddMonoid α] (x : αᵃᵒᵖ), 0 • x = 0 | null | false |
ContinuousAffineMap.precompA_apply | Mathlib.Topology.Algebra.ContinuousAffineMap.Topology | ∀ {R : Type u_1} {V : Type u_2} {W : Type u_3} {W₂ : Type u_4} {P : Type u_5} {Q : Type u_6} {Q₂ : Type u_7}
[inst : NormedField R] [inst_1 : AddCommGroup V] [inst_2 : Module R V] [inst_3 : TopologicalSpace V]
[inst_4 : AddTorsor V P] [inst_5 : TopologicalSpace P] [inst_6 : AddCommGroup W] [inst_7 : Module R W]
[... | null | true |
Lean.Lsp.LeanDidOpenTextDocumentParams._sizeOf_1 | Lean.Data.Lsp.Extra | Lean.Lsp.LeanDidOpenTextDocumentParams → ℕ | null | false |
SimpleGraph.completeAtomicBooleanAlgebra._proof_11 | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u_1} (G : SimpleGraph V) (v w : V), { Adj := Ne, symm := ⋯, loopless := ⋯ }.Adj v w → (G ⊔ Gᶜ).Adj v w | null | false |
MeasurableSpace.CountableOrCountablyGenerated.rec | Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated | {α : Type u_5} →
{β : Type u_6} →
[inst : MeasurableSpace β] →
{motive : MeasurableSpace.CountableOrCountablyGenerated α β → Sort u} →
((countableOrCountablyGenerated : Countable α ∨ MeasurableSpace.CountablyGenerated β) → motive ⋯) →
(t : MeasurableSpace.CountableOrCountablyGenerated α β)... | null | false |
Summable.tsum_eq_add_tsum_ite' | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {L : SummationFilter β}
[T2Space α] [ContinuousAdd α] [inst_4 : DecidableEq β] [L.LeAtTop] [L.NeBot] {f : β → α} (b : β),
Summable (Function.update f b 0) L → ∑'[L] (x : β), f x = f b + ∑'[L] (x : β), if x = b then 0 else f x | Version of `tsum_eq_add_tsum_ite` for `AddCommMonoid` rather than `AddCommGroup`.
Requires a different convergence assumption involving `Function.update`. | true |
Lean.Elab.Term.PostponeBehavior | Lean.Elab.SyntheticMVars | Type | Auxiliary type for `synthesizeSyntheticMVars`. It specifies
whether pending synthetic metavariables can be postponed or not.
| true |
_private.Lean.MonadEnv.0.Lean.isCtor?.match_1 | Lean.MonadEnv | (motive : Option Lean.AsyncConstantInfo → Sort u_1) →
(x : Option Lean.AsyncConstantInfo) →
((info : Lean.AsyncConstantInfo) →
(name : Lean.Name) →
(sig : Task Lean.ConstantVal) →
(constInfo : Task Lean.ConstantInfo) →
(h : info = { name := name, kind := Lean.ConstantKi... | null | false |
MeasureTheory.AEEqFun.compMeasurePreserving_id | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace γ] [inst_1 : MeasurableSpace β] {ν : MeasureTheory.Measure β}
(g : β →ₘ[ν] γ), g.compMeasurePreserving id ⋯ = g | null | true |
CategoryTheory.coherentTopology.equivalence | Mathlib.CategoryTheory.Sites.Coherent.SheafComparison | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(F : CategoryTheory.Functor C D) →
[inst_2 : F.PreservesFiniteEffectiveEpiFamilies] →
[inst_3 : F.ReflectsFiniteEffectiveEpiFamilies] →
[i... | The equivalence from coherent sheaves on `C` to coherent sheaves on `D`, given a fully faithful
functor `F : C ⥤ D` to a precoherent category, which preserves and reflects effective epimorphic
families, and satisfies `F.EffectivelyEnough`.
| true |
instDecidableRelAdjFromRelOfDecidableEq._aux_1 | Mathlib.Combinatorics.SimpleGraph.Basic | {V : Type u_1} → [DecidableEq V] → (r : V → V → Prop) → [DecidableRel r] → DecidableRel (SimpleGraph.fromRel r).Adj | null | false |
_private.Lean.Elab.SyntheticMVars.0.Lean.Elab.Term.initFn._@.Lean.Elab.SyntheticMVars.3625312754._hygCtx._hyg.4 | Lean.Elab.SyntheticMVars | IO (Lean.Option Bool) | null | false |
Batteries.Tactic.Lint.traceLintCore | Batteries.Tactic.Lint.Frontend | String → Bool → Lean.CoreM Unit | Traces via `IO.println` if `inIO` is `true`, and via `trace[...]` otherwise. It seems that
`trace` messages in a running `CoreM` are not propagated through to `IO` in the current setup. We
use `IO.println` directly instead of running `printTraces` at the end of our `CoreM` action so that
trace messages are printed to s... | true |
_private.Init.Data.Int.Linear.0.Int.Internal.Linear.Expr.toPoly'.go.match_1.eq_1 | Init.Data.Int.Linear | ∀ (motive : Int.Internal.Linear.Expr → Sort u_1) (k : ℤ) (h_1 : (k : ℤ) → motive (Int.Internal.Linear.Expr.num k))
(h_2 : (v : Int.Internal.Linear.Var) → motive (Int.Internal.Linear.Expr.var v))
(h_3 : (a b : Int.Internal.Linear.Expr) → motive (a.add b))
(h_4 : (a b : Int.Internal.Linear.Expr) → motive (a.sub b))... | null | true |
Turing.ToPartrec.Code.zero.eq_1 | Mathlib.Computability.TuringMachine.Config | Turing.ToPartrec.Code.zero = Turing.ToPartrec.Code.zero'.cons Turing.ToPartrec.Code.nil | null | true |
_private.Mathlib.Topology.UniformSpace.UniformEmbedding.0.completeSpace_extension.match_1_19 | Mathlib.Topology.UniformSpace.UniformEmbedding | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] {m : β → α} (g : Filter α)
(motive : (∃ x, Filter.map m (Filter.comap m g) ≤ nhds x) → Prop) (x : ∃ x, Filter.map m (Filter.comap m g) ≤ nhds x),
(∀ (x : α) (hx : Filter.map m (Filter.comap m g) ≤ nhds x), motive ⋯) → motive x | null | false |
RootPairing.EmbeddedG2.allRoots_eq_map_allCoeffs | Mathlib.LinearAlgebra.RootSystem.Finite.G2 | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N)
[inst_5 : P.EmbeddedG2] [Finite ι] [CharZero R] [IsDomain R],
RootPairing.EmbeddedG2.allRoots P =
List.map... | null | true |
Equiv.Perm.cycle_is_cycleOf | Mathlib.GroupTheory.Perm.Cycle.Factors | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {f c : Equiv.Perm α} {a : α},
a ∈ c.support → c ∈ f.cycleFactorsFinset → c = f.cycleOf a | If c is a cycle, a ∈ c.support and c is a cycle of f, then `c = f.cycleOf a` | true |
PresheafOfModules.Submodule.mk.inj | Mathlib.Algebra.Category.ModuleCat.Presheaf.Submodule | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {R : CategoryTheory.Functor Cᵒᵖ RingCat}
{M : PresheafOfModules R} {obj : (X : Cᵒᵖ) → Submodule ↑(R.obj X) ↑(M.obj X)}
{map : ∀ {X Y : Cᵒᵖ} (f : X ⟶ Y), obj X ≤ Submodule.comap (M.restrictₛₗ f) (obj Y)}
{obj_1 : (X : Cᵒᵖ) → Submodule ↑(R.obj X) ↑(M.obj X... | null | true |
MonoidWithZero.mk.noConfusion | Mathlib.Algebra.GroupWithZero.Defs | {M₀ : Type u} →
{P : Sort u_1} →
{toMonoid : Monoid M₀} →
{toZero : Zero M₀} →
{zero_mul : ∀ (a : M₀), 0 * a = 0} →
{mul_zero : ∀ (a : M₀), a * 0 = 0} →
{toMonoid' : Monoid M₀} →
{toZero' : Zero M₀} →
{zero_mul' : ∀ (a : M₀), 0 * a = 0} →
... | null | false |
SimpleGraph.instDecidableRelAdjAddCayleyOfFintypeOfDecidableEqOfDecidablePredMemSet | Mathlib.Combinatorics.SimpleGraph.Cayley | {M : Type u_1} →
(s : Set M) →
[inst : Add M] →
[Fintype M] → [DecidableEq M] → [DecidablePred fun x => x ∈ s] → DecidableRel (SimpleGraph.addCayley s).Adj | null | true |
ContinuousAffineMap.decompLinearEquiv._proof_1 | Mathlib.Topology.Algebra.ContinuousAffineMap | ∀ (S : Type u_1) [inst : Ring S], RingHomInvPair (RingHom.id S) (RingHom.id S) | null | false |
Homeomorph.piCongrRight_apply | Mathlib.Topology.Homeomorph.Lemmas | ∀ {ι : Type u_5} {Y₁ : ι → Type u_6} {Y₂ : ι → Type u_7} [inst : (i : ι) → TopologicalSpace (Y₁ i)]
[inst_1 : (i : ι) → TopologicalSpace (Y₂ i)] (F : (i : ι) → Y₁ i ≃ₜ Y₂ i) (a : (i : ι) → Y₁ i) (i : ι),
(Homeomorph.piCongrRight F) a i = (F i) (a i) | null | true |
_private.Mathlib.NumberTheory.ModularForms.BoundedAtCusp.0.OnePoint.isBoundedAt_iff._simp_1_2 | Mathlib.NumberTheory.ModularForms.BoundedAtCusp | ∀ {f : UpperHalfPlane → ℂ} {k : ℤ}, OnePoint.infty.IsBoundedAt f k = UpperHalfPlane.IsBoundedAtImInfty f | null | false |
Set.IsIntersectingOf | Mathlib.Combinatorics.SetFamily.Intersecting | {α : Type u_1} → [DecidableEq α] → Set ℕ → Set (Finset α) → Prop | A family `𝒜` of finite subsets of `α` is `L`-intersecting if the intersection size of every pair of
distinct members of `𝒜` belongs to `L ⊆ ℕ`.
That is, for all `s, t ∈ 𝒜` with `s ≠ t`, we have `|(s ∩ t)| ∈ L`.
| true |
DiscreteQuotient.isOpen_preimage | Mathlib.Topology.DiscreteQuotient | ∀ {X : Type u_2} [inst : TopologicalSpace X] (S : DiscreteQuotient X) (A : Set (Quotient S.toSetoid)),
IsOpen (S.proj ⁻¹' A) | null | true |
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic.0.CStarAlgebra.isStrictlyPositive_iff_isStrictlyPositive_sqrt_and_eq_sqrt_mul_sqrt._proof_1_2 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | 2 ≠ 0 | null | false |
SkewPolynomial.C_mul_monomial | Mathlib.Algebra.SkewPolynomial.Basic | ∀ {R : Type u_1} {n : ℕ} [inst : Semiring R] {a b : R} [inst_1 : MulSemiringAction (Multiplicative ℕ) R],
SkewPolynomial.C a * (SkewPolynomial.monomial n) b = (SkewPolynomial.monomial n) (a * b) | null | true |
Std.HashMap.size_le_size_insertIfNew | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α] {k : α}
{v : β}, m.size ≤ (m.insertIfNew k v).size | null | true |
StandardEtalePair.instCommRingRing._proof_22 | Mathlib.RingTheory.Etale.StandardEtale | ∀ {R : Type u_1} [inst : CommRing R] (P : StandardEtalePair R),
autoParam (∀ (x : P.Ring), x ^ 0 = 1) Monoid.npow_zero._autoParam | null | false |
NNReal.measurableSpace._proof_3 | Mathlib.MeasureTheory.Constructions.BorelSpace.Basic | NNReal.measurableSpace._aux_1 ∅ | null | false |
CategoryTheory.WithTerminal.Hom.eq_2 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (a : C),
CategoryTheory.WithTerminal.star.Hom (CategoryTheory.WithTerminal.of a) = PEmpty.{v + 1} | null | true |
LightCondensed.discrete.congr_simp | Mathlib.Condensed.Discrete.Module | ∀ (C : Type w) [inst : CategoryTheory.Category.{u, w} C]
[inst_1 : CategoryTheory.HasSheafify (CategoryTheory.coherentTopology LightProfinite) C],
LightCondensed.discrete C = LightCondensed.discrete C | null | true |
AlgebraicGeometry.Scheme.Hom.copyBase._proof_2 | Mathlib.AlgebraicGeometry.Scheme | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X.Hom Y) (g : ↥X → ↥Y), ⇑f = g → Continuous g | null | false |
_private.Mathlib.Order.KrullDimension.0.Order.coheight_pos_of_lt_top._proof_1_1 | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : Preorder α] {x : α} [inst_1 : OrderTop α], x < ⊤ → ¬IsMax x | null | false |
CategoryTheory.Mon.instSymmetricCategory._proof_1 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.SymmetricCategory C] (X Y : CategoryTheory.Mon C), CategoryTheory.IsMonHom (β_ X.X Y.X).hom | null | false |
Ordinal.div_eq | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ {a b c : Ordinal.{u_4}}, b * c ≤ a → a < b * (c + 1) → a / b = c | null | true |
IsLindelof.disjoint_nhdsSet_right | Mathlib.Topology.Compactness.Lindelof | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X} {l : Filter X} [CountableInterFilter l],
IsLindelof s → (Disjoint l (nhdsSet s) ↔ ∀ x ∈ s, Disjoint l (nhds x)) | A filter `l` with the countable intersection property is disjoint with the neighborhood
filter of a Lindelöf set if and only if it is disjoint with the neighborhood filter of each point
of this set. | true |
Matrix.norm_def | Mathlib.Analysis.Matrix.Normed | ∀ {m : Type u_3} {n : Type u_4} {α : Type u_5} [inst : Fintype m] [inst_1 : Fintype n]
[inst_2 : SeminormedAddCommGroup α] (A : Matrix m n α), ‖A‖ = ‖fun i j => A i j‖ | null | true |
Vector.getElem_swap_left | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {i j : ℕ} (hi : i < n) (hj : j < n), (xs.swap i j hi hj)[i] = xs[j] | null | true |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balanceL.match_1.eq_5 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2}
(motive :
(l : Std.DTreeMap.Internal.Impl α β) →
l.Balanced → Std.DTreeMap.Internal.Impl.BalanceLPrecond l.size Std.DTreeMap.Internal.Impl.leaf.size → Sort u_3)
(ls : ℕ) (lk : α) (lv : β lk) (lls : ℕ) (k : α) (v : β k) (l r : Std.DTreeMap.Internal.Impl α β) (lrs : ℕ) (k... | null | true |
TopModuleCat.instPreadditive | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | (R : Type u) → [inst : Ring R] → [inst_1 : TopologicalSpace R] → CategoryTheory.Preadditive (TopModuleCat R) | null | true |
_private.Mathlib.RingTheory.RootsOfUnity.EnoughRootsOfUnity.0.HasEnoughRootsOfUnity.of_dvd.match_1_3 | Mathlib.RingTheory.RootsOfUnity.EnoughRootsOfUnity | ∀ (M : Type u_1) [inst : CommMonoid M] {n : ℕ} (motive : (∃ ζ, IsPrimitiveRoot ζ n) → Prop)
(x : ∃ ζ, IsPrimitiveRoot ζ n), (∀ (ζ : M) (hζ : IsPrimitiveRoot ζ n), motive ⋯) → motive x | null | false |
Vector.mapFinIdx_push | Init.Data.Vector.MapIdx | ∀ {α : Type u_1} {n : ℕ} {β : Type u_2} {xs : Vector α n} {a : α} {f : (i : ℕ) → α → i < n + 1 → β},
(xs.push a).mapFinIdx f = (xs.mapFinIdx fun i a h => f i a ⋯).push (f n a ⋯) | null | true |
TopHom.inf_apply | Mathlib.Order.Hom.Bounded | ∀ {α : Type u_2} {β : Type u_3} [inst : Top α] [inst_1 : SemilatticeInf β] [inst_2 : OrderTop β] (f g : TopHom α β)
(a : α), (f ⊓ g) a = f a ⊓ g a | null | true |
Submonoid.one | Mathlib.Algebra.Group.Submonoid.Defs | {M : Type u_4} → [inst : MulOneClass M] → (S : Submonoid M) → One ↥S | A submonoid of a monoid inherits a 1. | true |
Lean.Compiler.LCNF.UnreachableBranches.findVarValue | Lean.Compiler.LCNF.ElimDeadBranches | Lean.FVarId → Lean.Compiler.LCNF.UnreachableBranches.InterpM Lean.Compiler.LCNF.UnreachableBranches.Value | Obtain the `Value` associated with `var` from the context of `InterpM`.
If none is available return `Value.bot`.
| true |
_private.Batteries.Recycling.RBTree.Lemmas.0.RBTree.RBNode.del.match_1.eq_2 | Batteries.Recycling.RBTree.Lemmas | ∀ (motive : RBTree.RBColor → Sort u_1) (h_1 : Unit → motive RBTree.RBColor.black)
(h_2 : Unit → motive RBTree.RBColor.red),
(match RBTree.RBColor.red with
| RBTree.RBColor.black => h_1 ()
| RBTree.RBColor.red => h_2 ()) =
h_2 () | null | true |
WeierstrassCurve.Affine.map_addPolynomial | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Formula | ∀ {R : Type r} {S : Type s} [inst : CommRing R] [inst_1 : CommRing S] {W' : WeierstrassCurve.Affine R} (f : R →+* S)
(x y ℓ : R), (W'.map f).addPolynomial (f x) (f y) (f ℓ) = Polynomial.map f (W'.addPolynomial x y ℓ) | null | true |
SimplexCategory.δ₀Iter_succ'._auto_1 | Mathlib.AlgebraicTopology.SimplexCategory.DeltaZeroIter | Lean.Syntax | null | false |
Lean.KVMap._sizeOf_inst | Lean.Data.KVMap | SizeOf Lean.KVMap | null | false |
Mathlib.Tactic.Abel.Context.α | Mathlib.Tactic.Abel | Mathlib.Tactic.Abel.Context → Lean.Expr | The type of the ambient additive commutative group or monoid. | true |
DividedPowers.dpow_add' | Mathlib.RingTheory.DividedPowers.Basic | ∀ {A : Type u_1} [inst : CommSemiring A] {I : Ideal A} {a b : A} (hI : DividedPowers I) {n : ℕ},
a ∈ I → b ∈ I → hI.dpow n (a + b) = ∑ k ∈ Finset.range (n + 1), hI.dpow k a * hI.dpow (n - k) b | Variant of `DividedPowers.dpow_add` with a sum on `range (n + 1)` | true |
ContinuousLinearEquiv.symm_smul_apply | Mathlib.Topology.Algebra.Module.Equiv.Basic | ∀ {S : Type u_1} {R : Type u_2} {V : Type u_3} {W : Type u_4} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid V] [inst_3 : Module R V] [inst_4 : TopologicalSpace V] [inst_5 : Module S V]
[inst_6 : ContinuousConstSMul S V] [inst_7 : AddCommMonoid W] [inst_8 : Module R W] [inst_9 : TopologicalSpace ... | null | true |
CategoryTheory.Functor.Elements.instCreatesLimitsOfShapeπ | Mathlib.CategoryTheory.Limits.Elements | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{A : CategoryTheory.Functor C (Type w)} →
{I : Type u₁} →
[inst_1 : CategoryTheory.Category.{v₁, u₁} I] →
[Small.{w, u₁} I] →
[CategoryTheory.Limits.HasLimitsOfShape I C] →
[CategoryTheory.Limits.Preserves... | null | true |
_private.Mathlib.Tactic.ClickSuggestions.FindPremises.0.Mathlib.Tactic.ClickSuggestions.isMVarSwap.go._sparseCasesOn_11 | Mathlib.Tactic.ClickSuggestions.FindPremises | {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 |
_private.Mathlib.Tactic.ComputeAsymptotics.Multiseries.Monomial.Basic.0.Tactic.ComputeAsymptotics.UnitMonomial.isLittleO_of_lt._simp_1_6 | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Monomial.Basic | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | null | false |
CategoryTheory.GrothendieckTopology.Point.rec | Mathlib.CategoryTheory.Sites.Point.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{motive : J.Point → Sort u_1} →
((fiber : CategoryTheory.Functor C (Type w)) →
(isCofiltered : CategoryTheory.IsCofiltered fiber.Elements) →
(initiallySmall : CategoryTh... | null | false |
ContinuousWithinAt.sqrt | Mathlib.Analysis.Real.Sqrt | ∀ {α : Type u_1} [inst : TopologicalSpace α] {f : α → ℝ} {s : Set α} {x : α},
ContinuousWithinAt f s x → ContinuousWithinAt (fun x => √(f x)) s x | null | true |
_private.Mathlib.NumberTheory.ModularForms.Derivative.0.Derivative.normalizedDerivOfComplex_slash._simp_1_8 | Mathlib.NumberTheory.ModularForms.Derivative | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | null | false |
Poly.coe_mul | Mathlib.NumberTheory.Dioph | ∀ {α : Type u_1} (f g : Poly α), ⇑(f * g) = ⇑f * ⇑g | null | true |
instModuleKaehlerDifferentialOfSMulCommClass | Mathlib.RingTheory.Kaehler.Basic | (R : Type u_3) →
(S : Type u_2) →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
{R' : Type u_1} → [inst_3 : CommRing R'] → [inst_4 : Algebra R' S] → [SMulCommClass R R' S] → Module R' Ω[S⁄R] | null | true |
algebraMap_mem._simp_1 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {S : Type u_1} {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : SetLike S A] [OneMemClass S A] [SMulMemClass S R A] (s : S) (r : R), ((algebraMap R A) r ∈ s) = True | null | false |
RatFunc.ofFractionRing.sizeOf_spec | Mathlib.FieldTheory.RatFunc.Defs | ∀ {K : Type u} [inst : CommRing K] [inst_1 : SizeOf K] (toFractionRing : FractionRing (Polynomial K)),
sizeOf { toFractionRing := toFractionRing } = 1 + sizeOf toFractionRing | null | true |
_private.Mathlib.Analysis.Normed.Module.Ball.Homeomorph.0.OpenPartialHomeomorph.univUnitBall._simp_7 | Mathlib.Analysis.Normed.Module.Ball.Homeomorph | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
_private.Mathlib.GroupTheory.DivisibleHull.0.DivisibleHull.aux_archimedeanClassOrderHom_injective | Mathlib.GroupTheory.DivisibleHull | ∀ {M : Type u_2} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M],
Function.Injective ⇑(DivisibleHull.archimedeanClassOrderHom✝ M) | Use `Equiv.injective archimedeanClassOrderIso` for public API. | true |
CommRingCat.Opposite.effectiveEpi_of_faithfullyFlat | Mathlib.Algebra.Category.Ring.EqualizerPushout | ∀ {R S : CommRingCatᵒᵖ} (f : S ⟶ R), (CommRingCat.Hom.hom f.unop).FaithfullyFlat → CategoryTheory.EffectiveEpi f | Any map `f : S ⟶ R` in `CommRingCatᵒᵖ` with faithfully flat `f.unop.hom : R.unop ⟶ S.unop` is
an effective epimorphism. | true |
Algebra.FormallySmooth.liftOfSurjective._proof_2 | Mathlib.RingTheory.Smooth.Basic | ∀ {R : Type u_3} [inst : CommRing R] {B : Type u_1} [inst_1 : CommRing B] [inst_2 : Algebra R B] {C : Type u_2}
[inst_3 : CommRing C] [inst_4 : Algebra R C], RingHomClass (B →ₐ[R] C) B C | null | false |
Lean.Elab.Term.Do.ToCodeBlock.ToForInTermResult.ctorIdx | Lean.Elab.Do.Legacy | Lean.Elab.Term.Do.ToCodeBlock.ToForInTermResult → ℕ | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Integrals.Basic.0.integral_exp_mul_I_eq_sinc._simp_1_7 | Mathlib.Analysis.SpecialFunctions.Integrals.Basic | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False | null | false |
T4Space.toNormalSpace | Mathlib.Topology.Separation.Regular | ∀ {X : Type u} {inst : TopologicalSpace X} [self : T4Space X], NormalSpace X | null | true |
LightProfinite.NatUnionInfty | Mathlib.Topology.Category.LightProfinite.Sequence | LightProfinite | The one point compactification of the natural numbers as a light profinite set. | true |
Finset.addDysonETransform.eq_1 | Mathlib.Combinatorics.Additive.ETransform | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : AddCommGroup α] (e : α) (x : Finset α × Finset α),
Finset.addDysonETransform e x = (x.1 ∪ (e +ᵥ x.2), x.2 ∩ (-e +ᵥ x.1)) | null | true |
_private.Mathlib.Topology.EMetricSpace.Paracompact.0.Metric.instParacompactSpace._proof_10 | Mathlib.Topology.EMetricSpace.Paracompact | ∀ (n k m : ℕ), n + k + 1 ≤ m → n < m | null | false |
CategoryTheory.MorphismProperty.comp_mem_paths_iff._simp_1 | Mathlib.CategoryTheory.PathCategory.MorphismProperty | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W : CategoryTheory.MorphismProperty C} {X Y Z : C}
{p : Quiver.Path X Y} {q : Quiver.Path Y Z}, W.paths (p.comp q) = (W.paths p ∧ W.paths q) | null | false |
Int.dvd_of_mul_dvd | Init.Data.Int.Cooper | ∀ {a b c : ℤ}, a * b ∣ a * c → 0 < a → b ∣ c | null | true |
Algebra.Extension.Hom.mapKer.congr_simp | Mathlib.RingTheory.Etale.Kaehler | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {P : Algebra.Extension R S}
{R' : Type u_1} {S' : Type u_2} [inst_3 : CommRing R'] [inst_4 : CommRing S'] [inst_5 : Algebra R' S']
{P' : Algebra.Extension R' S'} [inst_6 : Algebra R R'] [inst_7 : Algebra S S'] (f f_1 : P.Ho... | null | true |
_private.Mathlib.CategoryTheory.Sites.Over.0.CategoryTheory.GrothendieckTopology.overEquiv_symm_mem_over._simp_1_1 | Mathlib.CategoryTheory.Sites.Over | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {X : C}
{Y : CategoryTheory.Over X} (S : CategoryTheory.Sieve Y),
(S ∈ (J.over X) Y) = ((CategoryTheory.Sieve.overEquiv Y) S ∈ J Y.left) | null | false |
List.mem_permutationsAux2 | Mathlib.Data.List.Permutation | ∀ {α : Type u_1} {t : α} {ts ys l l' : List α},
l' ∈ (List.permutationsAux2 t ts [] ys fun x => l ++ x).2 ↔
∃ l₁ l₂, l₂ ≠ [] ∧ ys = l₁ ++ l₂ ∧ l' = l ++ l₁ ++ t :: l₂ ++ ts | null | true |
_private.Lean.Meta.Iterator.0.Lean.Meta.Iterator.filterMapM.match_1 | Lean.Meta.Iterator | {β : Type} →
(motive : Option β → Sort u_1) → (r : Option β) → (Unit → motive none) → ((r : β) → motive (some r)) → motive r | null | false |
AlgebraicGeometry.instQuasiCompactFstScheme | Mathlib.AlgebraicGeometry.Morphisms.QuasiCompact | ∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X ⟶ Z) (g : Y ⟶ Z) [AlgebraicGeometry.QuasiCompact g],
AlgebraicGeometry.QuasiCompact (CategoryTheory.Limits.pullback.fst f g) | null | true |
Nat.bitCasesOn_bit | Mathlib.Data.Nat.BinaryRec | ∀ {motive : ℕ → Sort u} (h : (b : Bool) → (n : ℕ) → motive (Nat.bit b n)) (b : Bool) (n : ℕ),
Nat.bitCasesOn (Nat.bit b n) h = h b n | null | true |
CategoryTheory.MonoidalOpposite.mopMopEquivalenceFunctorMonoidal._proof_8 | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(X : Cᴹᵒᵖᴹᵒᵖ),
(CategoryTheory.MonoidalCategoryStruct.leftUnitor
((CategoryTheory.MonoidalOpposite.mopMopEquivalence C).functor.obj X)).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheo... | null | false |
Stream'.map_cons | Mathlib.Data.Stream.Init | ∀ {α : Type u} {β : Type v} (f : α → β) (a : α) (s : Stream' α),
Stream'.map f (Stream'.cons a s) = Stream'.cons (f a) (Stream'.map f s) | null | true |
ContinuousMultilinearMap.isUniformInducing_toUniformOnFun | Mathlib.Topology.Algebra.Module.Multilinear.Topology | ∀ {𝕜 : Type u_1} {ι : Type u_2} {E : ι → Type u_3} {F : Type u_4} [inst : NormedField 𝕜]
[inst_1 : (i : ι) → TopologicalSpace (E i)] [inst_2 : (i : ι) → AddCommGroup (E i)]
[inst_3 : (i : ι) → Module 𝕜 (E i)] [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F] [inst_6 : UniformSpace F]
[inst_7 : IsUniformAddGroup... | null | true |
CategoryTheory.ObjectProperty.instSmallStrictColimitsOfShapeOfSmallOfLocallySmall | 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] [CategoryTheory.ObjectProperty.Small.{w, v_1, u_1} P]
[CategoryTheory.LocallySmall.{w, v_1, u_1} C] [Small.{w, u'} J] [CategoryTheory.LocallySmall.{w, v', ... | null | true |
Hyperreal._aux_Mathlib_Analysis_Real_Hyperreal___unexpand_Hyperreal_epsilon_1 | Mathlib.Analysis.Real.Hyperreal | Lean.PrettyPrinter.Unexpander | null | false |
Module.quotientAnnihilator._proof_1 | Mathlib.Algebra.Module.Torsion.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M],
(Module.annihilator R M).IsTwoSided | null | false |
Std.TreeMap.forIn_toList | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} (c : Std.TreeMap α β cmp), ForIn.toList c = c.toList | null | true |
LieModule.Weight.instFunLike | Mathlib.Algebra.Lie.Weights.Basic | {R : Type u_2} →
{L : Type u_3} →
(M : Type u_4) →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : LieAlgebra R L] →
[inst_3 : AddCommGroup M] →
[inst_4 : Module R M] →
[inst_5 : LieRingModule L M] →
[inst_6 : LieModule R L... | null | true |
_private.Lean.Elab.Deriving.Basic.0.Lean.Elab.elabDeriving._regBuiltin.Lean.Elab.elabDeriving_1 | Lean.Elab.Deriving.Basic | IO Unit | null | false |
ProbabilityTheory.Kernel.boolKernel_true | Mathlib.Probability.Kernel.Basic | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ ν : MeasureTheory.Measure α},
(ProbabilityTheory.Kernel.boolKernel μ ν) true = ν | null | true |
CategoryTheory.FunctorToTypes.coprod._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.FunctorToTypes | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] (F G : CategoryTheory.Functor C (Type u_1)) {X Y Z : C}
(x : X ⟶ Y) (x_1 : Y ⟶ Z),
TypeCat.ofHom
(Sum.map ⇑(CategoryTheory.ConcreteCategory.hom (F.map (CategoryTheory.CategoryStruct.comp x x_1)))
⇑(CategoryTheory.ConcreteCategory.hom (G.ma... | null | false |
Nat.mul_max_mul_left | Init.Data.Nat.MinMax | ∀ (a b c : ℕ), max (a * b) (a * c) = a * max b c | null | true |
Primrec.nat_double_succ | Mathlib.Computability.Primrec.Basic | Primrec fun n => 2 * n + 1 | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.