name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Units.isOpenMap_val | Mathlib.Analysis.Normed.Ring.Units | ∀ {R : Type u_1} [inst : NormedRing R] [HasSummableGeomSeries R], IsOpenMap Units.val | In a normed ring with summable geometric series, the coercion from `Rˣ` (equipped with the
induced topology from the embedding in `R × R`) to `R` is an open map. | true |
IsSemisimpleModule.recOn | Mathlib.RingTheory.SimpleModule.Basic | {R : Type u_2} →
[inst : Ring R] →
{M : Type u_4} →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
{motive : IsSemisimpleModule R M → Sort u} →
(t : IsSemisimpleModule R M) →
([toComplementedLattice : ComplementedLattice (Submodule R M)] → motive ⋯) → motive ... | null | false |
_private.Lean.Elab.ConfigEval.DeriveEvalConfigItem.0.Lean.Elab.ConfigEval.HandlerTrie.below_2 | Lean.Elab.ConfigEval.DeriveEvalConfigItem | {motive_1 : Lean.Elab.ConfigEval.HandlerTrie✝ → Sort u} →
{motive_2 : Array (String × Lean.Elab.ConfigEval.HandlerTrie✝) → Sort u} →
{motive_3 : List (String × Lean.Elab.ConfigEval.HandlerTrie✝) → Sort u} →
{motive_4 : String × Lean.Elab.ConfigEval.HandlerTrie✝ → Sort u} →
List (String × Lean.Elab.C... | null | false |
Pi.instSub | Mathlib.Algebra.Notation.Pi.Defs | {ι : Type u_1} → {G : ι → Type u_4} → [(i : ι) → Sub (G i)] → Sub ((i : ι) → G i) | null | true |
_private.Batteries.Tactic.Lint.Misc.0.Batteries.Tactic.Lint.unusedArguments.match_11 | Batteries.Tactic.Lint.Misc | (motive : String × String → Sort u_1) →
(x : String × String) → ((lBracket rBracket : String) → motive (lBracket, rBracket)) → motive x | null | false |
Lean.Elab.Attribute.kind | Lean.Elab.Attributes | Lean.Elab.Attribute → Lean.AttributeKind | null | true |
RingPreordering.support.congr_simp | Mathlib.Algebra.Order.Ring.Ordering.Basic | ∀ {R : Type u_1} [inst : CommRing R] (P P_1 : RingPreordering R) (e_P : P = P_1) [inst_1 : P.HasIdealSupport],
P.support = P_1.support | null | true |
_private.Mathlib.CategoryTheory.GlueData.0.CategoryTheory.GlueData.π_epi._proof_1 | Mathlib.CategoryTheory.GlueData | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (D : CategoryTheory.GlueData C)
[inst_1 : CategoryTheory.Limits.HasMulticoequalizer D.diagram] [inst_2 : CategoryTheory.Limits.HasColimits C],
CategoryTheory.Epi D.π | null | false |
Set.Definable.compl | Mathlib.ModelTheory.Definability | ∀ {M : Type w} {A : Set M} {L : FirstOrder.Language} [inst : L.Structure M] {α : Type u₁} {s : Set (α → M)},
A.Definable L s → A.Definable L sᶜ | null | true |
MeasurableEmbedding.measurable | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {f : α → β},
MeasurableEmbedding f → Measurable f | A measurable embedding is a measurable function. | true |
CategoryTheory.HasProjectiveResolution | Mathlib.CategoryTheory.Preadditive.Projective.Resolution | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.Limits.HasZeroObject C] → [CategoryTheory.Limits.HasZeroMorphisms C] → C → Prop | An object admits a projective resolution.
| true |
TrivialLieModule.instLieRingModule._proof_1 | Mathlib.Algebra.Lie.Abelian | ∀ (R : Type u_1) (L : Type u_2) (M : Type u_3) [inst : AddCommGroup M] (x y : L) (m : TrivialLieModule R L M), 0 = 0 + 0 | null | false |
PresheafOfModules.instIsLocalizationSheafOfModulesSheafificationInverseImageFunctorOppositeAbWToPresheaf | Mathlib.Algebra.Category.ModuleCat.Sheaf.Localization | ∀ {C : Type u'} [inst : CategoryTheory.Category.{v', u'} C] {J : CategoryTheory.GrothendieckTopology C}
{R₀ : CategoryTheory.Functor Cᵒᵖ RingCat} {R : CategoryTheory.Sheaf J RingCat} (α : R₀ ⟶ R.obj)
[inst_1 : CategoryTheory.Presheaf.IsLocallyInjective J α] [inst_2 : CategoryTheory.Presheaf.IsLocallySurjective J α]... | null | true |
Std.DHashMap.get?_eq_some_getD | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [inst : LawfulBEq α] {a : α}
{fallback : β a}, a ∈ m → m.get? a = some (m.getD a fallback) | null | true |
Finset.sup_eq_sSup_image | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_2} {β : Type u_3} [inst : CompleteLattice β] (s : Finset α) (f : α → β), s.sup f = sSup (f '' ↑s) | null | true |
CategoryTheory.IsSplitEpi.mk | Mathlib.CategoryTheory.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {f : X ⟶ Y},
Nonempty (CategoryTheory.SplitEpi f) → CategoryTheory.IsSplitEpi f | null | true |
instContMDiffVectorBundleOfNatWithTopENat_1 | Mathlib.Geometry.Manifold.VectorBundle.Basic | ∀ {𝕜 : Type u_1} {B : Type u_2} (F : Type u_3) (E : B → Type u_5) [inst : NontriviallyNormedField 𝕜] {EB : Type u_6}
[inst_1 : NormedAddCommGroup EB] [inst_2 : NormedSpace 𝕜 EB] {HB : Type u_7} [inst_3 : TopologicalSpace HB]
{IB : ModelWithCorners 𝕜 EB HB} [inst_4 : TopologicalSpace B] [inst_5 : ChartedSpace HB... | null | true |
Tactic.ComputeAsymptotics.MultiseriesExpansion.Multiseries.toSeq | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Defs | {basis_hd : ℝ → ℝ} →
{basis_tl : Tactic.ComputeAsymptotics.Basis} →
Tactic.ComputeAsymptotics.MultiseriesExpansion.Multiseries basis_hd basis_tl →
Stream'.Seq (ℝ × Tactic.ComputeAsymptotics.MultiseriesExpansion basis_tl) | Converts a `Multiseries basis_hd basis_tl` to a `Seq (ℝ × MultiseriesExpansion basis_tl)`. | true |
Finset.bipartiteAbove_swap | Mathlib.Combinatorics.Enumerative.DoubleCounting | ∀ {α : Type u_2} {β : Type u_3} (r : α → β → Prop) (s : Finset α) (b : β) [inst : (a : α) → Decidable (r a b)],
Finset.bipartiteAbove (Function.swap r) s b = Finset.bipartiteBelow r s b | null | true |
AddCommMonCat.instConcreteCategoryAddMonoidHomCarrier | Mathlib.Algebra.Category.MonCat.Basic | CategoryTheory.ConcreteCategory AddCommMonCat fun x1 x2 => ↑x1 →+ ↑x2 | null | true |
PSet.Equiv._unsafe_rec | Mathlib.SetTheory.ZFC.PSet | PSet.{u_1} → PSet.{u_2} → Prop | null | false |
Ordinal.typein_lt_nat | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ (x : ℕ), (Ordinal.typein LT.lt).toRelEmbedding x = ↑x | null | true |
Std.Internal.Do.Assertion.NondetFun.evalsTo_apply_5 | Std.Internal.Do.Assertion | ∀ {σ₁ σ₂ σ₃ σ₄ σ₅ α : Type} (f : σ₁ → σ₂ → σ₃ → σ₄ → σ₅ → α) (a : α) (s₁ : σ₁) (s₂ : σ₂) (s₃ : σ₃) (s₄ : σ₄) (s₅ : σ₅),
Std.Internal.Do.Assertion.NondetFun.EvalsTo f a s₁ s₂ s₃ s₄ s₅ = (f s₁ s₂ s₃ s₄ s₅ = a) | null | true |
AddCommute.add_left._simp_1 | Mathlib.Algebra.Group.Commute.Defs | ∀ {S : Type u_3} [inst : AddSemigroup S] {a b c : S}, AddCommute a c → AddCommute b c → AddCommute (a + b) c = True | null | false |
_private.Mathlib.NumberTheory.Height.NumberField.0.Mathlib.Meta.Positivity.evalHeightTotalWeight._proof_1 | Mathlib.NumberTheory.Height.NumberField | ∀ (α : Q(Type)) (x : Q(Zero «$α»)) (__defeqres : PLift («$x» =Q Nat.instMulZeroClass.toZero)),
«$x» =Q Nat.instMulZeroClass.toZero | null | false |
_private.Init.Data.String.Lemmas.Pattern.TakeDrop.Char.0.String.Slice.endsWith_char_eq_false_iff_forall_append._simp_1_1 | Init.Data.String.Lemmas.Pattern.TakeDrop.Char | ∀ (b : Bool), (b = false) = ¬b = true | null | false |
Lean.Meta.FVarSubst.mk.injEq | Lean.Meta.Tactic.FVarSubst | ∀ (map map_1 : Lean.AssocList Lean.FVarId Lean.Expr), ({ map := map } = { map := map_1 }) = (map = map_1) | null | true |
_private.Mathlib.Probability.Distributions.Exponential.0.ProbabilityTheory.cdf_expMeasure_eq._simp_1_3 | Mathlib.Probability.Distributions.Exponential | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α] [AddLeftMono α] {a : α}, (-a ≤ 0) = (0 ≤ a) | null | false |
CategoryTheory.Functor.OplaxMonoidal.instIsIsoη | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{D : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.CartesianMonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.OplaxMonoidal] [CategoryTheory.Limits.Prese... | null | true |
Fin.range_castLE | Mathlib.Data.Fin.SuccPred | ∀ {n k : ℕ} (h : n ≤ k), Set.range (Fin.castLE h) = {i | ↑i < n} | null | true |
ContinuousLinearMap.FredholmPackage.eventually_nhds_isInvertible | Mathlib.Analysis.Normed.Operator.Fredholm.Open | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace 𝕜 E] [inst_4 : NormedSpace 𝕜 F] [CompleteSpace E]
{T₀ : E →L[𝕜] F} (pkg : T₀.FredholmPackage),
∀ᶠ (T : E →L[𝕜] F) in nhds T₀, (pkg.decCodom.... | Let `T₀ : E → F` be a Fredholm operator between two Banach spaces, and choose a
`FredholmPackage` for `T₀`; that is, fix topological decompositions `E = E₁ ⊕ E₀` and `F = F₁ ⊕ F₀`,
where `E₀` and `F₀` are finite dimensional, and such that in these decompositions we have
$T₀ = \begin{pmatrix} α₀ & 0 \cr 0 & 0 \end{pmatr... | true |
_private.Lean.Meta.Match.SolveOverlap.0.Lean.Meta.Match.injectionAny.match_1 | Lean.Meta.Match.SolveOverlap | (motive : Lean.Meta.InjectionResult → Sort u_1) →
(__do_lift : Lean.Meta.InjectionResult) →
(Unit → motive Lean.Meta.InjectionResult.solved) →
((mvarId : Lean.MVarId) →
(newEqs : Array Lean.FVarId) →
(remainingNames : List Lean.Name) →
motive (Lean.Meta.InjectionResult.su... | null | false |
IsDedekindDomain.HeightOneSpectrum.adicCompletion.instField._proof_13 | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDedekindDomain R] (K : Type u_2) [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R)
(a : IsDedekindDomain.HeightOneSpectrum.adicCompletion K v), a * 0 = 0 | null | false |
CategoryTheory.FilteredObject.isStrictHom | Mathlib.CategoryTheory.Filtration.Basic | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
(I : Type u_1) →
[inst_1 : CategoryTheory.Category.{u_2, u_1} I] →
CategoryTheory.MorphismProperty (CategoryTheory.FilteredObject C I) | The morphism property of strict morphisms of filtered objects. | true |
DistribSMul.compFun | Mathlib.Algebra.GroupWithZero.Action.Defs | {M : Type u_1} →
{N : Type u_6} → (A : Type u_7) → [inst : AddZeroClass A] → [DistribSMul M A] → (N → M) → DistribSMul N A | Compose a `DistribSMul` with a function, with scalar multiplication `f r' • m`.
See note [reducible non-instances]. | true |
Polynomial.reverse_add_C | Mathlib.Algebra.Polynomial.Reverse | ∀ {R : Type u_1} [inst : Semiring R] (p : Polynomial R) (t : R),
(p + Polynomial.C t).reverse = p.reverse + Polynomial.C t * Polynomial.X ^ p.natDegree | null | true |
RingNorm.eq_zero_of_map_eq_zero' | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | ∀ {R : Type u_2} [inst : NonUnitalNonAssocRing R] (self : RingNorm R) (x : R), self.toFun x = 0 → x = 0 | If the image under the seminorm is zero, then the argument is zero. | true |
WCovBy.eq_or_covBy._to_dual_1 | Mathlib.Order.Cover | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, b ⩿ a → a = b ∨ b ⋖ a | null | false |
CompactExhaustion.mk.inj | Mathlib.Topology.Compactness.SigmaCompact | ∀ {X : Type u_4} {inst : TopologicalSpace X} {toFun : ℕ → Set X} {isCompact' : ∀ (n : ℕ), IsCompact (toFun n)}
{subset_interior_succ' : ∀ (n : ℕ), toFun n ⊆ interior (toFun (n + 1))} {iUnion_eq' : ⋃ n, toFun n = Set.univ}
{toFun_1 : ℕ → Set X} {isCompact'_1 : ∀ (n : ℕ), IsCompact (toFun_1 n)}
{subset_interior_suc... | null | true |
Fin.shiftLeft | Init.Data.Fin.Basic | {n : ℕ} → Fin n → Fin n → Fin n | Bitwise left shift of bounded numbers, with wraparound on overflow.
Examples:
* `(1 : Fin 10) <<< (1 : Fin 10) = (2 : Fin 10)`
* `(1 : Fin 10) <<< (3 : Fin 10) = (8 : Fin 10)`
* `(1 : Fin 10) <<< (4 : Fin 10) = (6 : Fin 10)`
| true |
Matrix.uniqueEquiv_symm_apply | Mathlib.LinearAlgebra.Matrix.Unique | ∀ {m : Type u_1} {n : Type u_2} {A : Type u_3} [inst : Unique m] [inst_1 : Unique n] (a : A),
Matrix.uniqueEquiv.symm a = Matrix.of fun x x_1 => a | null | true |
Lean.Parser.Tactic.pushCast | Init.Tactics | Lean.ParserDescr | `push_cast` rewrites the goal to move certain coercions (*casts*) inward, toward the leaf nodes.
This uses `norm_cast` lemmas in the forward direction.
For example, `↑(a + b)` will be written to `↑a + ↑b`.
- `push_cast` moves casts inward in the goal.
- `push_cast at h` moves casts inward in the hypothesis `h`.
It can ... | true |
NonUnitalRingHom.codRestrict | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | {R : Type u} →
{S : Type v} →
[inst : NonUnitalNonAssocSemiring R] →
{F : Type u_1} →
[inst_1 : FunLike F R S] →
[inst_2 : NonUnitalNonAssocSemiring S] →
[NonUnitalRingHomClass F R S] →
{S' : Type u_2} →
[inst_4 : SetLike S' S] →
... | Restriction of a non-unital ring homomorphism to a non-unital subsemiring of the codomain. | true |
_private.Mathlib.Analysis.Normed.Lp.PiLp.0.PiLp.lipschitzWith_ofLp_aux._simp_1_3 | Mathlib.Analysis.Normed.Lp.PiLp | ∀ (p : True → Prop), (∀ (x : True), p x) = p True.intro | null | false |
Mathlib.Tactic.Abel._aux_Mathlib_Tactic_Abel___macroRules_Mathlib_Tactic_Abel_abel1!_1 | Mathlib.Tactic.Abel | Lean.Macro | null | false |
String.instDecidableIsValidForSlice | Init.Data.String.Basic | {s : String.Slice} → {p : String.Pos.Raw} → Decidable (String.Pos.Raw.IsValidForSlice s p) | null | true |
Matrix.transpose_replicateCol | Mathlib.LinearAlgebra.Matrix.RowCol | ∀ {m : Type u_2} {α : Type v} {ι : Type u_6} (v : m → α), (Matrix.replicateCol ι v).transpose = Matrix.replicateRow ι v | null | true |
Prod.swap_eq_iff_eq_swap | Mathlib.Data.Prod.Basic | ∀ {α : Type u_1} {β : Type u_2} {x : α × β} {y : β × α}, x.swap = y ↔ x = y.swap | null | true |
CategoryTheory.Pseudofunctor.whiskerLeft_mapId_inv_assoc | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.Pseudofunctor B C) {a b : B} (f : a ⟶ b) {Z : F.obj a ⟶ F.obj b}
(h : CategoryTheory.CategoryStruct.comp (F.map f) (F.map (CategoryTheory.CategoryStruct.id b)) ⟶ Z),
CategoryTheory.Categor... | null | true |
IntermediateField.exists_algHom_of_splits_of_aeval | Mathlib.FieldTheory.Extension | ∀ {F : Type u_1} {E : Type u_2} {K : Type u_3} [inst : Field F] [inst_1 : Field E] [inst_2 : Field K]
[inst_3 : Algebra F E] [inst_4 : Algebra F K],
(∀ (s : E), IsIntegral F s ∧ (Polynomial.map (algebraMap F K) (minpoly F s)).Splits) →
∀ {x : E} {y : K}, (Polynomial.aeval y) (minpoly F x) = 0 → ∃ φ, φ x = y | null | true |
_private.Mathlib.Data.Set.Lattice.Bounded.0.Set.pi_sdiff_pi_subset._simp_1_1 | Mathlib.Data.Set.Lattice.Bounded | ∀ {α : Type u} {s t : Set α} (x : α), (x ∈ s \ t) = (x ∈ s ∧ x ∉ t) | null | false |
Matrix.equiv_GL_linearindependent | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.Card | {𝔽 : Type u_1} → [inst : Field 𝔽] → [Fintype 𝔽] → (n : ℕ) → GL (Fin n) 𝔽 ≃ { s // LinearIndependent 𝔽 s } | Equivalence between `GL n F` and `n` vectors of length `n` that are linearly independent. Given
by sending a matrix to its columns. | true |
dvd_sub_comm | Mathlib.Algebra.Ring.Divisibility.Basic | ∀ {α : Type u_1} [inst : NonUnitalRing α] {a b c : α}, a ∣ b - c ↔ a ∣ c - b | null | true |
Finset.nontrivial_iff_ne_singleton | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} {s : Finset α} {a : α}, a ∈ s → (s.Nontrivial ↔ s ≠ {a}) | null | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.carry_succ._proof_1_4 | Init.Data.BitVec.Bitblast | ∀ {w : ℕ} (i : ℕ) (x y : BitVec w) (c : Bool),
¬(2 * 2 ^ i ≤ x.toNat % 2 ^ i + (2 ^ i + y.toNat % 2 ^ i) + c.toNat ↔
2 ^ i ≤ x.toNat % 2 ^ i + y.toNat % 2 ^ i + c.toNat) →
False | null | false |
PartOrdEmb.dual._proof_1 | Mathlib.Order.Category.PartOrdEmb | ∀ (X : PartOrdEmb),
PartOrdEmb.ofHom (PartOrdEmb.Hom.hom (CategoryTheory.CategoryStruct.id X)).dual =
CategoryTheory.CategoryStruct.id ↧(↑X)ᵒᵈ | null | false |
_private.Mathlib.Combinatorics.SetFamily.Shatter.0.Finset.card_le_card_shatterer._simp_1_9 | Mathlib.Combinatorics.SetFamily.Shatter | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) | null | false |
Plausible.InjectiveFunction.sliceSizes.eq_def | Mathlib.Testing.Plausible.Functions | ∀ (x : ℕ),
Plausible.InjectiveFunction.sliceSizes x =
let n := x;
if h : 0 < n then
have this := ⋯;
MLList.cons ⟨n, h⟩ (Plausible.InjectiveFunction.sliceSizes (n / 2))
else MLList.nil | null | true |
pure_le_nhds | Mathlib.Topology.Neighborhoods | ∀ {X : Type u} [inst : TopologicalSpace X], pure ≤ nhds | null | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.ult_eq_not_carry._simp_1_5 | Init.Data.BitVec.Bitblast | ∀ {p q : Prop} {x : Decidable p} {x_1 : Decidable q}, (decide p = decide q) = (p ↔ q) | null | false |
Lean.Elab.Term.MutualClosure.FixPoint.run | Lean.Elab.MutualDef | Array Lean.FVarId → Lean.Elab.Term.MutualClosure.UsedFVarsMap → Lean.Elab.Term.MutualClosure.UsedFVarsMap | null | true |
HomotopicalAlgebra.CofibrantObject.HoCat.localizerMorphismResolution_functor | Mathlib.AlgebraicTopology.ModelCategory.CofibrantObjectHomotopy | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : HomotopicalAlgebra.ModelCategory C],
(HomotopicalAlgebra.CofibrantObject.HoCat.localizerMorphismResolution C).functor =
HomotopicalAlgebra.CofibrantObject.HoCat.resolution | null | true |
CategoryTheory.LocalizerMorphism.LeftResolution.op | Mathlib.CategoryTheory.Localization.Resolution | {C₁ : Type u_1} →
{C₂ : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] →
{W₁ : CategoryTheory.MorphismProperty C₁} →
{W₂ : CategoryTheory.MorphismProperty C₂} →
{Φ : CategoryTheory.LocalizerMorphism W₁ W₂} →
... | The canonical map `Φ.LeftResolution X₂ → Φ.op.RightResolution (Opposite.op X₂)`. | true |
ContMDiffOn.of_succ | Mathlib.Geometry.Manifold.ContMDiff.Defs | ∀ {𝕜 : 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] {E' : Type u_5} [inst_6 : NormedAddComm... | null | true |
CategoryTheory.Functor.PushoutObjObj.ofIsInitialLeft._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u_6} {C₂ : Type u_4} {C₃ : Type u_2} [inst : CategoryTheory.Category.{u_5, u_6} C₁]
[inst_1 : CategoryTheory.Category.{u_3, u_4} C₂] [inst_2 : CategoryTheory.Category.{u_1, u_2} C₃]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)) {X₁ Y₁ : C₁} (f₁ : X₁ ⟶ Y₁) {X₂ Y₂ : C₂} (f₂ : X₂ ⟶ Y₂)
... | null | false |
Function.HasFiniteSupport.sup | Mathlib.Algebra.FiniteSupport.Basic | ∀ {α : Type u_1} {M : Type u_2} [inst : Zero M] [inst_1 : SemilatticeSup M] {f g : α → M},
Function.HasFiniteSupport f → Function.HasFiniteSupport g → Function.HasFiniteSupport fun a => f a ⊔ g a | null | true |
BoxIntegral.Prepartition.splitMany_insert | Mathlib.Analysis.BoxIntegral.Partition.Split | ∀ {ι : Type u_1} (I : BoxIntegral.Box ι) (s : Finset (ι × ℝ)) (p : ι × ℝ),
BoxIntegral.Prepartition.splitMany I (insert p s) =
BoxIntegral.Prepartition.splitMany I s ⊓ BoxIntegral.Prepartition.split I p.1 p.2 | null | true |
NonemptyFinLinOrd.ofHom | Mathlib.Order.Category.NonemptyFinLinOrd | {X Y : Type u} →
[inst : Nonempty X] →
[inst_1 : LinearOrder X] →
[inst_2 : Fintype X] →
[inst_3 : Nonempty Y] → [inst_4 : LinearOrder Y] → [inst_5 : Fintype Y] → (X →o Y) → (↧X ⟶ ↧Y) | Typecheck a `OrderHom` as a morphism in `NonemptyFinLinOrd`. | true |
Ideal.under_under | Mathlib.RingTheory.Ideal.Over | ∀ {A : Type u_2} [inst : CommSemiring A] {B : Type u_3} [inst_1 : CommSemiring B] {C : Type u_4} [inst_2 : Semiring C]
[inst_3 : Algebra A B] [inst_4 : Algebra B C] [inst_5 : Algebra A C] [IsScalarTower A B C] (𝔓 : Ideal C),
Ideal.under A (Ideal.under B 𝔓) = Ideal.under A 𝔓 | null | true |
IsDedekindDomain.HeightOneSpectrum.adicCompletion.valueGroupEquiv._proof_3 | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ {R : Type u_2} [inst : CommRing R] [inst_1 : IsDedekindDomain R] (K : Type u_1) [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R),
MonoidWithZeroHomClass
(Valuation (IsDedekindDomain.HeightOneSpectrum.valuation K v).Completion (WithZero (Multipl... | null | false |
_private.Init.Data.Int.LemmasAux.0.Int.min_assoc._proof_1_1 | Init.Data.Int.LemmasAux | ∀ (a b c : ℤ), ¬min (min a b) c = min a (min b c) → False | null | false |
DilationEquiv.smulTorsor._proof_1 | Mathlib.Analysis.Normed.Affine.AddTorsor | ∀ {𝕜 : Type u_2} {E : Type u_1} [inst : NormedDivisionRing 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : Module 𝕜 E]
{P : Type u_3} [inst_3 : PseudoMetricSpace P] [inst_4 : NormedAddTorsor E P] (c : P) {k : 𝕜},
k ≠ 0 → ∀ (x : E), (k⁻¹ • fun x => x -ᵥ c) ((fun x => k • x +ᵥ c) x) = x | null | false |
Finset.Nontrivial.pow._f | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : CancelMonoid α] {s : Finset α},
s.Nontrivial → ∀ (x : ℕ) (f : Nat.below (motive := fun x => x ≠ 0 → (s ^ x).Nontrivial) x), x ≠ 0 → (s ^ x).Nontrivial | null | false |
Nat.maxPrimeFac | Mathlib.Data.Nat.MaxPrimeFac | ℕ → ℕ | The greatest prime divisor of a natural number `n > 1`.
At the exceptional inputs `n = 0` and `n = 1`, it returns the explicit default `n` because
`n.primeFactorsList` is empty. | true |
List.infix_filter_iff | Init.Data.List.Sublist | ∀ {α : Type u_1} {p : α → Bool} {l₁ l₂ : List α}, l₂ <:+: List.filter p l₁ ↔ ∃ l, l <:+: l₁ ∧ l₂ = List.filter p l | null | true |
continuousAt_pi | Mathlib.Topology.Constructions | ∀ {X : Type u} {ι : Type u_2} {A : ι → Type u_3} [inst : TopologicalSpace X] [T : (i : ι) → TopologicalSpace (A i)]
{f : X → (i : ι) → A i} {x : X}, ContinuousAt f x ↔ ∀ (i : ι), ContinuousAt (fun y => f y i) x | null | true |
Std.Do.SPred.true_intro | Std.Do.SPred.DerivedLaws | ∀ {σs : List (Type u)} {P : Std.Do.SPred σs}, P ⊢ₛ ⌜True⌝ | null | true |
Filter.Tendsto.inf_nhds | Mathlib.Topology.Order.Lattice | ∀ {L : Type u_1} [inst : TopologicalSpace L] {α : Type u_3} {l : Filter α} {f g : α → L} {x y : L} [inst_1 : Min L]
[ContinuousInf L],
Filter.Tendsto f l (nhds x) → Filter.Tendsto g l (nhds y) → Filter.Tendsto (fun i => f i ⊓ g i) l (nhds (x ⊓ y)) | null | true |
_private.Mathlib.Tactic.Abel.0.Mathlib.Tactic.Abel.addG.match_1 | Mathlib.Tactic.Abel | (motive : Lean.Name → Sort u_1) →
(x : Lean.Name) → ((p : Lean.Name) → (s : String) → motive (p.str s)) → ((n : Lean.Name) → motive n) → motive x | null | false |
Lean.Parser.Tactic.tacticSeq1Indented | Lean.Parser.Term.Basic | Lean.Parser.Parser | null | true |
BoxIntegral.Box.Ioo_subset_coe | Mathlib.Analysis.BoxIntegral.Box.Basic | ∀ {ι : Type u_1} (I : BoxIntegral.Box ι), BoxIntegral.Box.Ioo I ⊆ ↑I | null | true |
_private.Mathlib.SetTheory.Cardinal.NatCard.0.Multiset.Nodup.card_le_natCard._simp_1_1 | Mathlib.SetTheory.Cardinal.NatCard | ∀ (α : Type u_3), Nat.card α = Set.univ.ncard | null | false |
List.IsChain.rel_getLast_head_of_append | Mathlib.Data.List.Chain | ∀ {α : Type u_1} {R : α → α → Prop} {l₁ l₂ : List α},
List.IsChain R (l₁ ++ l₂) → ∀ (h₁ : l₁ ≠ []) (h₂ : l₂ ≠ []), R (l₁.getLast h₁) (l₂.head h₂) | null | true |
Order.PFilter.sInf_gc | Mathlib.Order.PFilter | ∀ {P : Type u_1} [inst : CompleteSemilatticeInf P],
GaloisConnection (fun x => OrderDual.toDual (Order.PFilter.principal x)) fun F => sInf ↑(OrderDual.ofDual F) | null | true |
FormalMultilinearSeries.coeff_eq_zero | Mathlib.Analysis.Calculus.FormalMultilinearSeries | ∀ {𝕜 : Type u} {E : Type v} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {p : FormalMultilinearSeries 𝕜 𝕜 E} {n : ℕ}, p.coeff n = 0 ↔ p n = 0 | null | true |
Lean.Elab.Tactic.Grind.saveTacticInfoForToken | Lean.Elab.Tactic.Grind.Basic | Lean.Syntax → Lean.Elab.Tactic.Grind.GrindTacticM Unit | Save the current tactic state for a token `stx`.
This method is a no-op if `stx` has no position information.
We use this method to save the tactic state at punctuation such as `;`
| true |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balanceLErase.match_5.splitter | Std.Data.DTreeMap.Internal.Balancing | {α : Type u_1} →
{β : α → Type u_2} →
(rs : ℕ) →
(k : α) →
(v : β k) →
(l r : Std.DTreeMap.Internal.Impl α β) →
(motive :
(l_1 : Std.DTreeMap.Internal.Impl α β) →
l_1.Balanced →
Std.DTreeMap.Internal.Impl.BalanceLErasePrecon... | null | true |
Subsemigroup.range_subtype | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} [inst : Mul M] (s : Subsemigroup M), (MulMemClass.subtype s).srange = s | null | true |
TestFunction.coe_sub | Mathlib.Analysis.Distribution.TestFunction | ∀ {F : Type u_2} {α : Type u_4} {β : Type u_5} [inst : FunLike F α β] [inst_1 : Sub F] [inst_2 : Sub β]
[IsSubApply F α β] (f g : F), ⇑(f - g) = ⇑f - ⇑g | **Alias** of `FunLike.coe_sub`. | true |
CochainComplex.isStrictlyGE_mappingCone._auto_1 | Mathlib.Algebra.Homology.HomotopyCategory.Plus | Lean.Syntax | null | false |
Rack.instDivInvMonoidEnvelGroup._proof_2 | Mathlib.Algebra.Quandle | ∀ (R : Type u_1) [inst : Rack R] (a b c : Rack.EnvelGroup R), a * b * c = a * (b * c) | null | false |
ValuationSubring.instFieldSubtypeMemTop._proof_4 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u_1} [inst : Field K], SubringClass (Subfield K) K | null | false |
ContinuousLinearMap.prodₗᵢ | Mathlib.Analysis.Normed.Operator.Prod | {𝕜 : Type u_1} →
{E : Type u_2} →
{F : Type u_3} →
{G : Type u_4} →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : SeminormedAddCommGroup E] →
[inst_2 : SeminormedAddCommGroup F] →
[inst_3 : SeminormedAddCommGroup G] →
[inst_4 : NormedSpace 𝕜 E]... | `ContinuousLinearMap.prod` as a `LinearIsometryEquiv`. | true |
String.Pos.Raw.isValidForSlice_stringSliceTo | Init.Data.String.Basic | ∀ {s : String} {p : s.Pos} {q : String.Pos.Raw},
String.Pos.Raw.IsValidForSlice (s.sliceTo p) q ↔ q ≤ p.offset ∧ String.Pos.Raw.IsValid s q | null | true |
Std.Http.Internal.Mock.Server.noConfusion | Std.Http.Transport | {P : Sort u} → {t t' : Std.Http.Internal.Mock.Server} → t = t' → Std.Http.Internal.Mock.Server.noConfusionType P t t' | null | false |
instSubInt16 | Init.Data.SInt.Basic | Sub Int16 | null | true |
ContinuousLinearEquiv.comp_differentiableAt_iff | Mathlib.Analysis.Calculus.FDeriv.Equiv | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Type u_4}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] (iso : E ≃L[𝕜] F) {f : G → E} {x : G... | null | true |
_private.Mathlib.Data.List.Basic.0.List.erase_getElem._proof_1_6 | Mathlib.Data.List.Basic | ∀ {ι : Type u_1} [inst : BEq ι] (a : ι) (l : List ι) (n : ℕ) (hi : n + 1 < (a :: l).length),
n + 1 ≤ ((a :: l).erase (a :: l)[n + 1]).length → n < ((a :: l).erase (a :: l)[n + 1]).length | null | false |
mul_self_sub_one | Mathlib.Algebra.Ring.Commute | ∀ {R : Type u} [inst : NonAssocRing R] (a : R), a * a - 1 = (a + 1) * (a - 1) | null | true |
CategoryTheory.Triangulated.TStructure.truncGEδLT_comp_truncLTι_app | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLTGE | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryTheory.... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.