name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Set.notMem_of_notMem_sUnion | Mathlib.Data.Set.Lattice.Bounded | ∀ {α : Type u_1} {x : α} {t : Set α} {S : Set (Set α)}, x ∉ ⋃₀ S → t ∈ S → x ∉ t | null | true |
CategoryTheory.Limits.HasCountableLimits.recOn | Mathlib.CategoryTheory.Limits.Shapes.Countable | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{motive : CategoryTheory.Limits.HasCountableLimits C → Sort u} →
(t : CategoryTheory.Limits.HasCountableLimits C) →
((out :
∀ (J : Type) [inst_1 : CategoryTheory.SmallCategory J] [CategoryTheory.CountableCategory J],
... | null | false |
USize.and_le_left | Init.Data.UInt.Bitwise | ∀ {a b : USize}, a &&& b ≤ a | null | true |
Cycle.support_formPerm | Mathlib.GroupTheory.Perm.Cycle.Concrete | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] (s : Cycle α) (h : s.Nodup),
s.Nontrivial → (s.formPerm h).support = s.toFinset | null | true |
right_iff_ite_iff | Init.PropLemmas | ∀ {p : Prop} [inst : Decidable p] {x y : Prop}, (y ↔ if p then x else y) ↔ p → y = x | null | true |
CategoryTheory.TwistShiftData.z_zero_right | Mathlib.CategoryTheory.Shift.Twist | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : Type w} [inst_1 : AddMonoid A]
[inst_2 : CategoryTheory.HasShift C A] (t : CategoryTheory.TwistShiftData C A) (a : A), t.z a 0 = 1 | null | true |
isPreconnected_iff_subset_of_fully_disjoint_closed | Mathlib.Topology.Connected.Clopen | ∀ {α : Type u} [inst : TopologicalSpace α] {s : Set α},
IsClosed s → (IsPreconnected s ↔ ∀ (u v : Set α), IsClosed u → IsClosed v → s ⊆ u ∪ v → Disjoint u v → s ⊆ u ∨ s ⊆ v) | A closed set `s` is preconnected if and only if for every cover by two closed sets that are
disjoint, it is contained in one of the two covering sets. | true |
Submultiplicative.lim.eq_1 | Mathlib.Analysis.Subadditive | ∀ {u : ℕ → ℝ} (_h : Submultiplicative u), _h.lim = sInf ((fun n => u n ^ (↑n)⁻¹) '' Set.Ici 1) | null | true |
Submodule.rank_quotient_add_rank | Mathlib.LinearAlgebra.Dimension.RankNullity | ∀ {R : Type u_1} {M : Type u} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[HasRankNullity.{u, u_1} R] (N : Submodule R M), Module.rank R (M ⧸ N) + Module.rank R ↥N = Module.rank R M | null | true |
FundamentalGroup.map | Mathlib.AlgebraicTopology.FundamentalGroupoid.FundamentalGroup | {X : Type u_1} →
{Y : Type u_2} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] → (f : C(X, Y)) → (x : X) → FundamentalGroup X x →* FundamentalGroup Y (f x) | The homomorphism between fundamental groups induced by a continuous map. | true |
_private.Mathlib.Topology.MetricSpace.Thickening.0.Metric.eventually_notMem_cthickening_of_infEDist_pos._simp_1_2 | Mathlib.Topology.MetricSpace.Thickening | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) | null | false |
Submonoid.LocalizationMap.mk'_eq_zero_iff | Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoidWithZero N]
(f : S.LocalizationMap N) (m : M) (s : ↥S), f.mk' m s = 0 ↔ ∃ s, ↑s * m = 0 | null | true |
subset_countableInfClosure._simp_1 | Mathlib.Order.CountableSupClosed | ∀ {α : Type u_2} {s : Set α} [inst : Preorder α], (s ⊆ countableInfClosure s) = True | null | false |
_private.Mathlib.RingTheory.Ideal.Operations.0.Submodule.smul_le_span._simp_1_1 | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u_1} [inst : CommSemiring R] (s : Set R), Ideal.span s = s • ⊤ | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Prod.0.SimpleGraph.reachable_boxProd.match_1_3 | Mathlib.Combinatorics.SimpleGraph.Prod | ∀ {α : Type u_1} {β : Type u_2} {G : SimpleGraph α} {H : SimpleGraph β} {x y : α × β}
(motive : G.Reachable x.1 y.1 ∧ H.Reachable x.2 y.2 → Prop) (h : G.Reachable x.1 y.1 ∧ H.Reachable x.2 y.2),
(∀ (w₁ : G.Walk x.1 y.1) (w₂ : H.Walk x.2 y.2), motive ⋯) → motive h | null | false |
PrimeSpectrum.BasicConstructibleSetData.recOn | Mathlib.RingTheory.Spectrum.Prime.ConstructibleSet | {R : Type u_1} →
{motive : PrimeSpectrum.BasicConstructibleSetData R → Sort u} →
(t : PrimeSpectrum.BasicConstructibleSetData R) →
((f : R) → (n : ℕ) → (g : Fin n → R) → motive { f := f, n := n, g := g }) → motive t | null | false |
PolynomialLaw.toFun'_eq_of_inclusion | Mathlib.RingTheory.PolynomialLaw.Basic | ∀ {R : Type u} [inst : CommSemiring R] {M : Type u_1} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_2}
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] {S : Type v} [inst_5 : CommSemiring S] [inst_6 : Algebra R S]
(f : M →ₚₗ[R] N) {A : Type u} [inst_7 : CommSemiring A] [inst_8 : Algebra R A] {φ : A →... | Compare the values of `PolynomialLaw.toFun'` in a square diagram,
when one of the maps is a subalgebra inclusion. | true |
List.SublistForall₂.recOn | Mathlib.Data.List.Forall2 | ∀ {α : Type u_1} {β : Type u_2} {R : α → β → Prop}
{motive : (a : List α) → (a_1 : List β) → List.SublistForall₂ R a a_1 → Prop} {a : List α} {a_1 : List β}
(t : List.SublistForall₂ R a a_1),
(∀ {l : List β}, motive [] l ⋯) →
(∀ {a₁ : α} {a₂ : β} {l₁ : List α} {l₂ : List β} (a : R a₁ a₂) (a_2 : List.SublistFo... | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int.0.Int.reduceToNat._regBuiltin.Int.reduceToNat.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int.3578908840._hygCtx._hyg.22 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int | IO Unit | null | false |
Lake.Hash.noConfusion | Lake.Build.Trace | {P : Sort u} → {t t' : Lake.Hash} → t = t' → Lake.Hash.noConfusionType P t t' | null | false |
DistribMulActionHom.instCoeTCOfAddDistribAddActionSemiHomClassCoeAddMonoidHom.eq_1 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_1} [inst : Monoid M] {N : Type u_2} [inst_1 : Monoid N] {φ : M →* N} {A : Type u_4} [inst_2 : AddMonoid A]
[inst_3 : DistribMulAction M A] {B : Type u_5} [inst_4 : AddMonoid B] [inst_5 : DistribMulAction N B] {F : Type u_10}
[inst_6 : FunLike F A B] [inst_7 : DistribMulActionSemiHomClass F (⇑φ) A B],
... | null | true |
Monoid.PushoutI.NormalWord.head | Mathlib.GroupTheory.PushoutI | {ι : Type u_1} →
{G : ι → Type u_2} →
{H : Type u_3} →
[inst : (i : ι) → Group (G i)] →
[inst_1 : Group H] →
{φ : (i : ι) → H →* G i} → {d : Monoid.PushoutI.NormalWord.Transversal φ} → Monoid.PushoutI.NormalWord d → H | Every `NormalWord` is the product of an element of the base group and a word made up
of letters each of which is in the transversal. `head` is that element of the base group. | true |
Std.Time.TimeZone.instInhabitedUTLocal.default | Std.Time.Zoned.ZoneRules | Std.Time.TimeZone.UTLocal | null | true |
ProbabilityTheory.BrownianReal.covMatrix_submatrix | Mathlib.Probability.BrownianMotion.GaussianProjectiveFamily | ∀ {I J : Finset NNReal} (hJI : J ⊆ I),
((ProbabilityTheory.BrownianReal.covMatrix I).submatrix (fun i => ⟨↑i, ⋯⟩) fun i => ⟨↑i, ⋯⟩) =
ProbabilityTheory.BrownianReal.covMatrix J | null | true |
_private.Lean.Linter.Util.0.Lean.Linter.findMatchingDecl?.match_3 | Lean.Linter.Util | (motive : Option Lean.DeclarationRanges → Sort u_1) →
(__x : Option Lean.DeclarationRanges) →
((ranges : Lean.DeclarationRanges) → motive (some ranges)) →
((x : Option Lean.DeclarationRanges) → motive x) → motive __x | null | false |
Lean.Lsp.DidCloseTextDocumentParams | Lean.Data.Lsp.TextSync | Type | null | true |
_private.Mathlib.Topology.UniformSpace.UniformConvergence.0.tendstoUniformlyOn_singleton_iff_tendsto._simp_1_3 | Mathlib.Topology.UniformSpace.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {l₁ : Filter α} {l₂ : Filter β},
Filter.Tendsto f l₁ l₂ = ∀ s ∈ l₂, f ⁻¹' s ∈ l₁ | null | false |
_private.Lean.Data.FuzzyMatching.0.Lean.FuzzyMatching.Score.mk.sizeOf_spec | Lean.Data.FuzzyMatching | ∀ (inner : Int16), sizeOf { inner := inner } = 1 + sizeOf inner | null | true |
_private.Mathlib.RingTheory.IntegralClosure.IntegrallyClosed.0.Associated.pow_iff._simp_1_1 | Mathlib.RingTheory.IntegralClosure.IntegrallyClosed | ∀ {M : Type u_1} [inst : MonoidWithZero M] [IsLeftCancelMulZero M] {a b : M}, Associated a b = (a ∣ b ∧ b ∣ a) | null | false |
ModuleCat.limitAddCommGroup._aux_5 | Mathlib.Algebra.Category.ModuleCat.Limits | {R : Type u_4} →
[inst : Ring R] →
{J : Type u_3} →
[inst_1 : CategoryTheory.Category.{u_1, u_3} J] →
(F : CategoryTheory.Functor J (ModuleCat R)) →
[inst_2 : Small.{u_2, max u_3 u_2} ↑(F.comp (CategoryTheory.forget (ModuleCat R))).sections] →
ℤ →
(CategoryTheory.... | null | false |
LibraryNote.norm_num_lemma_function_equality | Mathlib.Tactic.NormNum.Basic | Batteries.Util.LibraryNote | Note: Many of the lemmas in this file use a function equality hypothesis like `f = HAdd.hAdd`
below. The reason for this is that when this is applied, to prove e.g. `100 + 200 = 300`, the
`+` here is `HAdd.hAdd` with an instance that may not be syntactically equal to the one supplied
by the `AddMonoidWithOne` instance,... | true |
AffineSubspace.instCompleteLattice._proof_2 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ {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] (x x_1 : AffineSubspace k P), ↑x ⊆ ↑(affineSpan k (↑x ∪ ↑x_1)) | null | false |
padicNormE.defn | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] (f : PadicSeq p) {ε : ℚ},
0 < ε → ∃ N, ∀ i ≥ N, padicNormE (Padic.mk f - ↑(↑f i)) < ε | null | true |
Lean.Grind.CommRing.Expr.denote_toPoly | Init.Grind.Ring.CommSolver | ∀ {α : Type u_1} [inst : Lean.Grind.CommRing α] (ctx : Lean.Grind.CommRing.Context α) (e : Lean.Grind.CommRing.Expr),
Lean.Grind.CommRing.Poly.denote ctx e.toPoly = Lean.Grind.CommRing.Expr.denote ctx e | null | true |
Lean.Meta.Grind.Arith.Linear.EqCnstrProof.coreCommRing.injEq | Lean.Meta.Tactic.Grind.Arith.Linear.Types | ∀ (a b : Lean.Expr) (ra rb : Lean.Grind.CommRing.Expr) (p : Lean.Grind.CommRing.Poly)
(lhs' : Lean.Meta.Grind.Arith.Linear.LinExpr) (a_1 b_1 : Lean.Expr) (ra_1 rb_1 : Lean.Grind.CommRing.Expr)
(p_1 : Lean.Grind.CommRing.Poly) (lhs'_1 : Lean.Meta.Grind.Arith.Linear.LinExpr),
(Lean.Meta.Grind.Arith.Linear.EqCnstrPr... | null | true |
_private.Mathlib.Probability.Kernel.Composition.ParallelComp.0.ProbabilityTheory.Kernel.wrapped._proof_1._@.Mathlib.Probability.Kernel.Composition.ParallelComp.4290254366._hygCtx._hyg.8 | Mathlib.Probability.Kernel.Composition.ParallelComp | @ProbabilityTheory.Kernel.definition✝ = @ProbabilityTheory.Kernel.definition✝ | null | false |
Complex.HadamardThreeLines.sSupNormIm | Mathlib.Analysis.Complex.Hadamard | {E : Type u_1} → [NormedAddCommGroup E] → (ℂ → E) → ℝ → ℝ | The supremum of the norm of `f` on imaginary lines. (Fixed real part)
This is also known as the function `M` | true |
NonUnitalSubalgebra.toNonUnitalSubsemiring'._proof_2 | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
(S T : NonUnitalSubalgebra R A), S.toNonUnitalSubsemiring = T.toNonUnitalSubsemiring → S = T | null | false |
_private.Lean.Compiler.LCNF.ToMono.0.Lean.Compiler.LCNF.LetValue.toMono.match_3 | Lean.Compiler.LCNF.ToMono | (motive : Option Lean.Compiler.LCNF.TrivialStructureInfo → Sort u_1) →
(__do_lift : Option Lean.Compiler.LCNF.TrivialStructureInfo) →
((info : Lean.Compiler.LCNF.TrivialStructureInfo) → motive (some info)) →
((x : Option Lean.Compiler.LCNF.TrivialStructureInfo) → motive x) → motive __do_lift | null | false |
FirstOrder.Language.orderLHom_onRelation | Mathlib.ModelTheory.Order | ∀ (L : FirstOrder.Language) [inst : L.IsOrdered] (x : ℕ) (x_1 : FirstOrder.Language.order.Relations x),
L.orderLHom.onRelation x_1 =
match x, x_1 with
| .(2), FirstOrder.Language.orderRel.le => FirstOrder.Language.leSymb | null | true |
CliffordAlgebra.instAlgebra'._proof_3 | Mathlib.LinearAlgebra.CliffordAlgebra.Basic | ∀ {R : Type u_3} {A : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommGroup M] [inst_2 : CommRing A]
[inst_3 : Algebra R A] [inst_4 : Module R M] [inst_5 : Module A M] (Q : QuadraticForm A M)
[inst_6 : IsScalarTower R A M] (r : R) (x : CliffordAlgebra Q),
(CliffordAlgebra.instAlgebra'._aux_1 Q) ... | null | false |
_private.Lean.Elab.Quotation.Precheck.0.Lean.Elab.Term.Quotation.precheckIdent._regBuiltin.Lean.Elab.Term.Quotation.precheckIdent_1 | Lean.Elab.Quotation.Precheck | IO Unit | null | false |
CategoryTheory.Limits.Cofork.ofCocone | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor CategoryTheory.Limits.WalkingParallelPair C} →
CategoryTheory.Limits.Cocone F →
CategoryTheory.Limits.Cofork (F.map CategoryTheory.Limits.WalkingParallelPairHom.left)
(F.map CategoryTheory.Limits.Walking... | Given `F : WalkingParallelPair ⥤ C`, which is really the same as
`parallelPair (F.map left) (F.map right)` and a cocone on `F`, we get a cofork on
`F.map left` and `F.map right`. | true |
CategoryTheory.Ind.yoneda.fullyFaithful | Mathlib.CategoryTheory.Limits.Indization.Category | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → CategoryTheory.Ind.yoneda.FullyFaithful | The functor `C ⥤ Ind C` is fully faithful. | true |
UniformConvergenceCLM.sub_apply | Mathlib.Topology.Algebra.Module.Spaces.UniformConvergenceCLM | ∀ {F : Type u_1} {α : outParam (Type u_2)} {β : outParam (Type u_3)} {inst : FunLike F α β} {inst_1 : Sub β}
{inst_2 : Sub F} [self : IsSubApply F α β] (f g : F) (x : α), (f - g) x = f x - g x | **Alias** of `sub_apply`. | true |
_private.Std.Data.DHashMap.Basic.0.Std.DHashMap.Const.insertManyIfNewUnit._proof_2 | Std.Data.DHashMap.Basic | ∀ {α : Type u_1} {x : BEq α} {x_1 : Hashable α} {ρ : Type u_2} [inst : ForIn Id ρ α] (m : Std.DHashMap α fun x => Unit)
(l : ρ), (↑↑(Std.DHashMap.Internal.Raw₀.Const.insertManyIfNewUnit ⟨m.inner, ⋯⟩ l)).WF | null | false |
Std.Sat.AIG.toGraphviz.toGraphvizString.match_1 | Std.Sat.AIG.Basic | {α : Type} →
(motive : Std.Sat.AIG.Decl α → Sort u_1) →
(x : Std.Sat.AIG.Decl α) →
(Unit → motive Std.Sat.AIG.Decl.false) →
((i : α) → motive (Std.Sat.AIG.Decl.atom i)) →
((l r : Std.Sat.AIG.Fanin) → motive (Std.Sat.AIG.Decl.gate l r)) → motive x | null | false |
Int.dvd_zero._simp_1 | Init.Data.Int.DivMod.Bootstrap | ∀ (n : ℤ), (n ∣ 0) = True | null | false |
ProbabilityTheory.IsMeasurableRatCDF.measurable_stieltjesFunction | Mathlib.Probability.Kernel.Disintegration.MeasurableStieltjes | ∀ {α : Type u_1} {f : α → ℚ → ℝ} [inst : MeasurableSpace α] (hf : ProbabilityTheory.IsMeasurableRatCDF f) (x : ℝ),
Measurable fun a => ↑(hf.stieltjesFunction a) x | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.get_insertIfNew._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
_private.Init.Data.Format.Basic.0.Std.Format.WorkGroup.fla | Init.Data.Format.Basic | Std.Format.WorkGroup✝ → Std.Format.FlattenAllowability | null | true |
Holor.cprankMax_1 | Mathlib.Data.Holor | ∀ {α : Type} {ds : List ℕ} [inst : Mul α] [inst_1 : AddMonoid α] {x : Holor α ds}, x.CPRankMax1 → Holor.CPRankMax 1 x | null | true |
Set.op_smul_set_mul_eq_mul_smul_set | Mathlib.Algebra.Group.Action.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Semigroup α] (a : α) (s t : Set α), MulOpposite.op a • s * t = s * a • t | null | true |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic.0.IsProperLinearSet.add_floor_neg_toNat_sum_eq | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | ∀ {ι : Type u_3} {s : Set (ι → ℕ)} (hs : IsProperLinearSet s) [inst : Finite ι] (x : ι → ℕ),
x + ∑ i, (-IsProperLinearSet.floor✝ hs x i).toNat • ↑i =
IsProperLinearSet.fract✝ hs x + ∑ i, (IsProperLinearSet.floor✝ hs x i).toNat • ↑i | null | true |
_private.Lean.Parser.Command.0.Lean.Parser.Command.tactic_extension._regBuiltin.Lean.Parser.Command.tactic_extension.declRange_5 | Lean.Parser.Command | IO Unit | null | false |
Concept.ofIsIntent._proof_1 | Mathlib.Order.Concept | ∀ {α : Type u_1} {β : Type u_2} (r : α → β → Prop) (t : Set β), lowerPolar r t = lowerPolar r t | null | false |
CategoryTheory.IsFiltered.isConnected | Mathlib.CategoryTheory.Filtered.Connected | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.IsFiltered C], CategoryTheory.IsConnected C | null | true |
isClopen_iInter | Mathlib.Topology.AlexandrovDiscrete | ∀ {ι : Sort u_1} {α : Type u_3} [inst : TopologicalSpace α] [AlexandrovDiscrete α] {f : ι → Set α},
(∀ (i : ι), IsClopen (f i)) → IsClopen (⋂ i, f i) | null | true |
_private.Lean.PrettyPrinter.Delaborator.Builtins.0.Lean.PrettyPrinter.Delaborator.delabOfNatCore._sparseCasesOn_1 | Lean.PrettyPrinter.Delaborator.Builtins | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((fn arg : Lean.Expr) → motive (fn.app arg)) → (Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | null | false |
matrixEquivTensor._proof_2 | Mathlib.RingTheory.MatrixAlgebra | ∀ (n : Type u_2) (R : Type u_1) (A : Type u_3) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Fintype n] [inst_4 : DecidableEq n],
Function.RightInverse (MatrixEquivTensor.equiv n R A).invFun (MatrixEquivTensor.equiv n R A).toFun | null | false |
BitVec.mul_succ | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x y : BitVec w}, x * (y + 1#w) = x * y + x | null | true |
Equiv.IicFinsetSet._proof_2 | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrderBot α] (a : α),
Function.LeftInverse (fun b => ⟨↑b, ⋯⟩) fun b => ⟨↑b, ⋯⟩ | null | false |
nhdsWithin_extChartAt_target_eq_of_mem | Mathlib.Geometry.Manifold.IsManifold.ExtChartAt | ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H] [inst_4 : TopologicalSpace M]
{I : ModelWithCorners 𝕜 E H} [inst_5 : ChartedSpace H M] {x : M} {z : E},
z ∈ (extChartAt I x)... | Around a point in the target, the neighborhoods are the same within `(extChartAt I x).target`
and within `range I`. | true |
Std.Internal.List.getValue?_insertList | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] [EquivBEq α] {l toInsert : List ((_ : α) × β)} {k : α},
Std.Internal.List.DistinctKeys l →
Std.Internal.List.DistinctKeys toInsert →
Std.Internal.List.getValue? k (Std.Internal.List.insertList l toInsert) =
(Std.Internal.List.getValue? k toInsert).or (Std.I... | null | true |
Algebra.norm | Mathlib.RingTheory.Norm.Defs | (R : Type u_1) → {S : Type u_2} → [inst : CommRing R] → [inst_1 : Ring S] → [Algebra R S] → S →* R | The norm of an element `s` of an `R`-algebra is the determinant of `(*) s`. | true |
HasFTaylorSeriesUpToOn.hasStrictFDerivAt | Mathlib.Analysis.Calculus.ContDiff.RCLike | ∀ {𝕂 : Type u_1} [inst : RCLike 𝕂] {E' : Type u_2} [inst_1 : NormedAddCommGroup E'] [inst_2 : NormedSpace 𝕂 E']
{F' : Type u_3} [inst_3 : NormedAddCommGroup F'] [inst_4 : NormedSpace 𝕂 F'] {n : WithTop ℕ∞} {s : Set E'}
{f : E' → F'} {x : E'} {p : E' → FormalMultilinearSeries 𝕂 E' F'},
HasFTaylorSeriesUpToOn ... | If a function has a Taylor series at order at least 1, then at points in the interior of the
domain of definition, the term of order 1 of this series is a strict derivative of `f`. | true |
LinearEquiv.multilinearMapCongrRight.congr_simp | Mathlib.LinearAlgebra.Multilinear.Finsupp | ∀ {R : Type uR} (S : Type uS) {ι : Type uι} {M₁ : ι → Type v₁} {M₂ : Type v₂} {M₃ : Type v₃} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : (i : ι) → Module R (M₁ i)] [inst_3 : AddCommMonoid M₂]
[inst_4 : Module R M₂] [inst_5 : Semiring S] [inst_6 : Module S M₂] [inst_7 : SMulCommClass R S ... | null | true |
RingCon.mk'._proof_1 | Mathlib.RingTheory.Congruence.Defs | ∀ {R : Type u_1} [inst : NonAssocSemiring R] (c : RingCon R), ↑1 = ↑1 | null | false |
WithZero.instPreorder._proof_3 | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u_1} [inst : Preorder α],
autoParam (∀ (a b : WithZero α), a < b ↔ a ≤ b ∧ ¬b ≤ a) Preorder.lt_iff_le_not_ge._autoParam | null | false |
RingEquiv.piMulOpposite._proof_4 | Mathlib.Algebra.Ring.Equiv | ∀ {ι : Type u_1} (S : ι → Type u_2) [inst : (i : ι) → NonUnitalNonAssocSemiring (S i)] (x x_1 : ((i : ι) → S i)ᵐᵒᵖ),
(fun i => MulOpposite.op (MulOpposite.unop (x + x_1) i)) = fun i => MulOpposite.op (MulOpposite.unop (x + x_1) i) | null | false |
CategoryTheory.Dial.tensorUnit_rel | Mathlib.CategoryTheory.Dialectica.Monoidal | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasFiniteProducts C]
[inst_2 : CategoryTheory.Limits.HasPullbacks C],
(CategoryTheory.MonoidalCategoryStruct.tensorUnit (CategoryTheory.Dial C)).rel = ⊤ | null | true |
Lean.Lsp.InlayHintParams.noConfusion | Lean.Data.Lsp.LanguageFeatures | {P : Sort u} → {t t' : Lean.Lsp.InlayHintParams} → t = t' → Lean.Lsp.InlayHintParams.noConfusionType P t t' | null | false |
NNDist.mk.noConfusion | Mathlib.Topology.MetricSpace.Pseudo.Defs | {α : Type u_3} →
{P : Sort u} →
{nndist nndist' : α → α → NNReal} → { nndist := nndist } = { nndist := nndist' } → (nndist ≍ nndist' → P) → P | null | false |
threeGPFree_smul_set₀ | Mathlib.Combinatorics.Additive.AP.Three.Defs | ∀ {α : Type u_2} [inst : CommMonoidWithZero α] [IsCancelMulZero α] [NoZeroDivisors α] {s : Set α} {a : α},
a ≠ 0 → (ThreeGPFree (a • s) ↔ ThreeGPFree s) | null | true |
ProbabilityTheory.Kernel.withDensity_zero' | Mathlib.Probability.Kernel.WithDensity | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (κ : ProbabilityTheory.Kernel α β)
[inst : ProbabilityTheory.IsSFiniteKernel κ], (κ.withDensity fun x x_1 => 0) = 0 | null | true |
Submodule.Quotient.addCommGroup._proof_5 | Mathlib.LinearAlgebra.Quotient.Defs | ∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (p : Submodule R M),
autoParam (∀ (a b : M ⧸ p), a - b = a + -b) SubNegMonoid.sub_eq_add_neg._autoParam | null | false |
Nat.Prime.dvd_primorial_iff | Mathlib.NumberTheory.Primorial | ∀ {p n : ℕ}, Nat.Prime p → (p ∣ primorial n ↔ p ≤ n) | null | true |
_private.Lean.Compiler.IR.LLVMBindings.0.Lean.LLVM.CodegenFileType.mk.noConfusion | Lean.Compiler.IR.LLVMBindings | {P : Sort u} → {val val' : UInt64} → { val := val } = { val := val' } → (val = val' → P) → P | null | false |
CategoryTheory.Limits.hasColimit_of_iso._to_dual_1 | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
{F G : CategoryTheory.Functor J C} [CategoryTheory.Limits.HasLimit F] (α : G ≅ F), CategoryTheory.Limits.HasLimit G | null | false |
CategoryTheory.Limits.ConeMorphism.w_assoc | 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} {A B : CategoryTheory.Limits.Cone F} (self : CategoryTheory.Limits.ConeMorphism A B)
(j : J) {Z : C} (h : F.obj j ⟶ Z),
CategoryTheory.CategoryStruct.comp self.h... | The triangle consisting of the two natural transformations and `hom` commutes | true |
IsTop.not_isBot | Mathlib.Order.Max | ∀ {α : Type u_1} [inst : PartialOrder α] {a : α} [Nontrivial α], IsTop a → ¬IsBot a | null | true |
bddOrd_dual_comp_forget_to_bipointed | Mathlib.Order.Category.BddOrd | BddOrd.dual.comp (CategoryTheory.forget₂ BddOrd Bipointed) =
(CategoryTheory.forget₂ BddOrd Bipointed).comp Bipointed.swap | null | true |
_private.Mathlib.Topology.Algebra.Group.OpenMapping.0.isOpenMap_smul_of_sigmaCompact._simp_1_1 | Mathlib.Topology.Algebra.Group.OpenMapping | ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
IsOpenMap f = ∀ (x : X), nhds (f x) ≤ Filter.map f (nhds x) | null | false |
_private.Mathlib.Tactic.Linter.FlexibleLinter.0.Mathlib.Linter.Flexible.Stained.toFMVarId.match_1 | Mathlib.Tactic.Linter.FlexibleLinter | (motive : Option Lean.LocalDecl → Sort u_1) →
(x : Option Lean.LocalDecl) → (Unit → motive none) → ((decl : Lean.LocalDecl) → motive (some decl)) → motive x | null | false |
String.Pos.le_slice_iff | Init.Data.String.Lemmas.Order | ∀ {s : String} {p₀ p₁ : s.Pos} {h : p₀ ≤ p₁} {p : (s.slice p₀ p₁ h).Pos} {q : s.Pos} {h₀ : p₀ ≤ q} {h₁ : q ≤ p₁},
p ≤ q.slice p₀ p₁ h₀ h₁ ↔ String.Pos.ofSlice p ≤ q | null | true |
Algebra.GrothendieckAddGroup.lift | Mathlib.GroupTheory.MonoidLocalization.GrothendieckGroup | {M : Type u_1} →
{G : Type u_2} →
[inst : AddCommMonoid M] → [inst_1 : AddCommGroup G] → (M →+ G) ≃ (Algebra.GrothendieckAddGroup M →+ G) | A monoid homomorphism from a monoid `M` to a group `G` lifts to a group homomorphism from the
Grothendieck group of `M` to `G`. | true |
_private.Lean.Elab.DocString.0.Lean.Doc.fixupInline.match_3 | Lean.Elab.DocString | (motive : Option (Lean.Doc.Ref✝ (Lean.Doc.Inline Lean.ElabInline)) → Sort u_1) →
(x : Option (Lean.Doc.Ref✝ (Lean.Doc.Inline Lean.ElabInline))) →
((r : Lean.Doc.Ref✝ (Lean.Doc.Inline Lean.ElabInline)) →
(content : Lean.Doc.Inline Lean.ElabInline) →
(location : Lean.Syntax) →
(seen : ... | null | false |
CategoryTheory.PrelaxFunctor.id._proof_3 | Mathlib.CategoryTheory.Bicategory.Functor.Prelax | ∀ (B : Type u_2) [inst : CategoryTheory.Bicategory B] {a b : B} {f g h : a ⟶ b} (η : f ⟶ g) (θ : g ⟶ h),
(CategoryTheory.PrelaxFunctorStruct.id B).map₂ (CategoryTheory.CategoryStruct.comp η θ) =
CategoryTheory.CategoryStruct.comp ((CategoryTheory.PrelaxFunctorStruct.id B).map₂ η)
((CategoryTheory.PrelaxFunc... | null | false |
Lean.Data.AC.EvalInformation.evalOp | Init.Data.AC | {α : Sort u} → {β : Sort v} → [self : Lean.Data.AC.EvalInformation α β] → α → β → β → β | null | true |
Matrix.ProjectiveSpecialLinearGroup | Mathlib.LinearAlgebra.Matrix.ProjectiveSpecialLinearGroup | (n : Type u) → [DecidableEq n] → [Fintype n] → (R : Type v) → [CommRing R] → Type (max (max u v) v u) | A projective special linear group is the quotient of a special linear group by its center. | true |
instModuleQuotientAddSubgroupTorsion._proof_2 | Mathlib.GroupTheory.Torsion | ∀ {M : Type u_1} [inst : AddCommGroup M], (AddCommGroup.torsion M).Normal | null | false |
ByteArray.findFinIdx?.loop | Init.Data.ByteArray.Basic | (a : ByteArray) → (UInt8 → Bool) → ℕ → Option (Fin a.size) | null | true |
PointedCone.map_id | Mathlib.Geometry.Convex.Cone.Pointed | ∀ {R : Type u_1} {E : Type u_2} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R]
[inst_3 : AddCommMonoid E] [inst_4 : Module R E] (C : PointedCone R E), PointedCone.map LinearMap.id C = C | null | true |
_private.Mathlib.Analysis.Calculus.FDeriv.Measurable.0.FDerivMeasurableAux.differentiable_set_subset_D._simp_1_5 | Mathlib.Analysis.Calculus.FDeriv.Measurable | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | null | false |
Plausible.TotalFunction.rec | Plausible.Functions | {α : Type u} →
{β : Type v} →
{motive : Plausible.TotalFunction α β → Sort u_1} →
((a : List ((_ : α) × β)) → (a_1 : β) → motive (Plausible.TotalFunction.withDefault a a_1)) →
(t : Plausible.TotalFunction α β) → motive t | null | false |
CategoryTheory.Functor.IsStronglyCocartesian.mk._flat_ctor | Mathlib.CategoryTheory.FiberedCategory.Cocartesian | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] [inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳]
{p : CategoryTheory.Functor 𝒳 𝒮} {R S : 𝒮} {a b : 𝒳} {f : R ⟶ S} {φ : a ⟶ b} [toIsHomLift : p.IsHomLift f φ],
(∀ {b' : 𝒳} (g : S ⟶ p.obj b') (φ' : a ⟶ b') [p.IsHomLift (CategoryTheory.Cat... | null | false |
_private.Init.Data.Vector.Perm.0.Vector.swap_perm._simp_1_2 | Init.Data.Vector.Perm | ∀ {α : Type u_1} {n : ℕ} {as bs : Vector α n}, as.Perm bs = as.toList.Perm bs.toList | null | false |
Mathlib.Tactic.Push.pullStep | Mathlib.Tactic.Push | Mathlib.Tactic.Push.Head → Lean.Meta.Simp.Simproc | Try to rewrite using a `pull` lemma. | true |
Function.locallyFinsuppWithin.restrictMonoidHom_apply | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] {U : Set X} {Y : Type u_2} [inst_1 : AddCommGroup Y] {V : Set X}
(D : Function.locallyFinsuppWithin U Y) (h : V ⊆ U),
(Function.locallyFinsuppWithin.restrictMonoidHom h) D = D.restrict h | null | true |
_private.Lean.Elab.DocString.0.Lean.Doc.findShadowedNames.match_3 | Lean.Elab.DocString | {α : Type} →
(motive : Lean.Name × α → Sort u_1) →
(x : Lean.Name × α) → ((fullName : Lean.Name) → (snd : α) → motive (fullName, snd)) → motive x | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.