name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
List.erase_eq_eraseIdx | Init.Data.List.Erase | ∀ {α : Type u_1} [inst : BEq α] (l : List α) (a : α),
l.erase a =
match List.idxOf? a l with
| none => l
| some i => l.eraseIdx i | null | true |
Bool.or_eq_true_iff | Init.Data.Bool | ∀ {x y : Bool}, (x || y) = true ↔ x = true ∨ y = true | null | true |
ContinuousMap.instCStarAlgebra._proof_1 | Mathlib.Analysis.CStarAlgebra.ContinuousMap | ∀ {A : Type u_1} [inst : CStarAlgebra A], IsTopologicalSemiring A | null | false |
Stream'.WSeq.bind_assoc._simp_1 | Mathlib.Data.WSeq.Relation | ∀ {α : Type u} {β : Type v} {γ : Type w} (s : Stream'.WSeq α) (f : α → Stream'.WSeq β) (g : β → Stream'.WSeq γ),
((s.bind f).bind g ~ʷ s.bind fun x => (f x).bind g) = True | null | false |
Function.End.mul_def | Mathlib.Algebra.Group.Action.End | ∀ {α : Type u_5} (f g : Function.End α), f * g = f ∘ g | null | true |
ContinuousLinearEquiv.symm_comp_self | Mathlib.Topology.Algebra.Module.Equiv | ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁}
[inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂] {M₁ : Type u_4} [inst_4 : TopologicalSpace M₁]
[inst_5 : AddCommMonoid M₁] {M₂ : Type u_5} [inst_6 : TopologicalSpace M₂] [inst_7 : Ad... | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.getKeyD_eq._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
Aesop.CompleteMatch.mk.inj | Aesop.Forward.Match.Types | ∀ {clusterMatches clusterMatches_1 : Array Aesop.Match},
{ clusterMatches := clusterMatches } = { clusterMatches := clusterMatches_1 } → clusterMatches = clusterMatches_1 | null | true |
Std.Time.ValidDate | Std.Time.Date.ValidDate | Bool → Type | Represents a valid date for a given year, considering whether it is a leap year. Example: `(2, 29)`
is valid only if `leap` is `true`.
| true |
IncidenceAlgebra.ext | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {𝕜 : Type u_2} {α : Type u_5} [inst : Zero 𝕜] [inst_1 : LE α] ⦃f g : IncidenceAlgebra 𝕜 α⦄,
(∀ (a b : α), a ≤ b → f a b = g a b) → f = g | null | true |
LocallyConstant.instNonAssocSemiring._proof_5 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : NonAssocSemiring Y] (x : ℕ)
(x_1 : LocallyConstant X Y), ⇑(x • x_1) = ⇑(x • x_1) | null | false |
tensorKaehlerQuotKerSqEquiv._proof_4 | Mathlib.RingTheory.Smooth.Kaehler | ∀ (P : Type u_1) (S : Type u_2) [inst : CommRing P] [inst_1 : CommRing S] [inst_2 : Algebra P S],
SMulCommClass (P ⧸ RingHom.ker (algebraMap P S) ^ 2) S S | null | false |
invOf_eq_left_inv | Mathlib.Algebra.Group.Invertible.Defs | ∀ {α : Type u} [inst : Monoid α] {a b : α} [inst_1 : Invertible a], b * a = 1 → ⅟a = b | null | true |
_private.Init.Data.Option.Lemmas.0.Option.none_lt._simp_1_1 | Init.Data.Option.Lemmas | ∀ {α : Type u_1} [inst : LT α] {a : α}, (none < some a) = True | null | false |
CategoryTheory.Oplax.StrongTrans.whiskerRight_naturality_naturality_app | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Oplax | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] {F G : CategoryTheory.OplaxFunctor B CategoryTheory.Cat}
(η : CategoryTheory.Oplax.StrongTrans F G) {a b : B} {a' : CategoryTheory.Cat} {f g : a ⟶ b} (β : f ⟶ g)
(h : G.obj b ⟶ a') (X : ↑(F.obj a)),
CategoryTheory.CategoryStruct.comp (h.toFunctor.map ((η.app b... | null | true |
_private.Std.Time.Format.Basic.0.Std.Time.instReprText.repr.match_1 | Std.Time.Format.Basic | (motive : Std.Time.Text → Sort u_1) →
(x : Std.Time.Text) →
(Unit → motive Std.Time.Text.short) →
(Unit → motive Std.Time.Text.full) → (Unit → motive Std.Time.Text.narrow) → motive x | null | false |
CategoryTheory.Comon.MonOpOpToComonObj | Mathlib.CategoryTheory.Monoidal.Comon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] → CategoryTheory.Mon Cᵒᵖ → CategoryTheory.Comon C | Turn a monoid object in the opposite category into a comonoid object.
| true |
_private.Mathlib.Probability.Distributions.Binomial.0.ProbabilityTheory.integrable_map_cast_binomial._simp_1_3 | Mathlib.Probability.Distributions.Binomial | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {ε : Type u_8} [inst : TopologicalSpace ε]
[inst_1 : ESeminormedAddMonoid ε] {f : α → ε},
MeasureTheory.Integrable f μ → ∀ {c : ENNReal}, c ≠ ⊤ → MeasureTheory.Integrable f (c • μ) = True | null | false |
HomotopicalAlgebra.CofibrantObject.HoCat.adj._proof_2 | Mathlib.AlgebraicTopology.ModelCategory.BifibrantObjectHomotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : HomotopicalAlgebra.ModelCategory C]
(X : HomotopicalAlgebra.BifibrantObject.HoCat C),
CategoryTheory.CategoryStruct.comp
(HomotopicalAlgebra.CofibrantObject.HoCat.adjUnit.app
(HomotopicalAlgebra.BifibrantObject.HoCat.ιCofibrantOb... | null | false |
Interval.addCommMonoid._proof_4 | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_1} [inst : AddCommMonoid α] [inst_1 : Preorder α] [inst_2 : IsOrderedAddMonoid α] (a : Interval α),
0 + a = a | null | false |
Std.ExtTreeSet.isSome_min?_of_isSome_min?_erase | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k : α},
(t.erase k).min?.isSome = true → t.min?.isSome = true | null | true |
TensorProduct.AlgebraTensorModule.map_tmul | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ {R : Type uR} {A : Type uA} {M : Type uM} {N : Type uN} {P : Type uP} {Q : Type uQ} [inst : CommSemiring R]
[inst_1 : Semiring A] [inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module A M]
[inst_6 : IsScalarTower R A M] [inst_7 : AddCommMonoid N] [inst_8 : Module R N] [inst_9 : ... | null | true |
String.contains_slice_iff | Init.Data.String.Lemmas.Pattern.Find.String | ∀ {t : String.Slice} {s : String}, s.contains t = true ↔ t.copy.toList <:+: s.toList | null | true |
cfc_inv | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : Semifield R] [inst_1 : StarRing R] [inst_2 : MetricSpace R]
[inst_3 : IsTopologicalSemiring R] [inst_4 : ContinuousStar R] [inst_5 : TopologicalSpace A] [inst_6 : Ring A]
[inst_7 : StarRing A] [inst_8 : Algebra R A] [inst_9 : ContinuousFunctionalCalculus R A p]... | null | true |
Set.encard_le_encard_iff_encard_diff_le_encard_diff | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s t : Set α}, (s ∩ t).Finite → (s.encard ≤ t.encard ↔ (s \ t).encard ≤ (t \ s).encard) | **Alias** of `Set.encard_le_encard_iff_encard_sdiff_le_encard_sdiff`. | true |
Std.TreeMap.getKey?_ofList_of_contains_eq_false | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [Std.TransCmp cmp] [inst : BEq α] [Std.LawfulBEqCmp cmp]
{l : List (α × β)} {k : α}, (List.map Prod.fst l).contains k = false → (Std.TreeMap.ofList l cmp).getKey? k = none | null | true |
Set.infs_subset_iff | Mathlib.Data.Set.Sups | ∀ {α : Type u_2} [inst : SemilatticeInf α] {s t u : Set α}, s ⊼ t ⊆ u ↔ ∀ a ∈ s, ∀ b ∈ t, a ⊓ b ∈ u | null | true |
_private.Mathlib.Geometry.Euclidean.Angle.Oriented.Basic.0.Orientation.oangle_smul_add_right_eq_zero_or_eq_pi_iff._simp_1_3 | Mathlib.Geometry.Euclidean.Angle.Oriented.Basic | ∀ {ι : Type u'} {R : Type u_2} {M : Type u_4} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{v : ι → M} [inst_3 : Fintype ι], (¬LinearIndependent R v) = ∃ g, ∑ i, g i • v i = 0 ∧ ∃ i, g i ≠ 0 | null | false |
CategoryTheory.ShortComplex.ShortExact.exactAt_X₁._auto_3 | Mathlib.Algebra.Homology.HomologySequenceLemmas | Lean.Syntax | null | false |
ContinuousAlgEquiv.image_symm_eq_preimage | Mathlib.Topology.Algebra.Algebra.Equiv | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : TopologicalSpace A] [inst_3 : Semiring B] [inst_4 : TopologicalSpace B] [inst_5 : Algebra R A]
[inst_6 : Algebra R B] (e : A ≃A[R] B) (S : Set B), ⇑e.symm '' S = ⇑e ⁻¹' S | null | true |
DoubleCentralizer.instInhabited | Mathlib.Analysis.CStarAlgebra.Multiplier | {𝕜 : Type u_1} →
{A : Type u_2} →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : NonUnitalNormedRing A] →
[inst_2 : NormedSpace 𝕜 A] →
[inst_3 : SMulCommClass 𝕜 A A] → [inst_4 : IsScalarTower 𝕜 A A] → Inhabited (DoubleCentralizer 𝕜 A) | null | true |
UInt8.toUSize_ofNat' | Init.Data.UInt.Lemmas | ∀ {n : ℕ}, n < UInt8.size → (UInt8.ofNat n).toUSize = USize.ofNat n | null | true |
ZMod.dft_eq_fourier | Mathlib.Analysis.Fourier.ZMod | ∀ {N : ℕ} [inst : NeZero N] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℂ E] [CompleteSpace E]
(Φ : ZMod N → E) (k : ZMod N), ZMod.dft Φ k = Fourier.fourierIntegral ZMod.toCircle MeasureTheory.Measure.count Φ k | The discrete Fourier transform agrees with the general one (assuming the target space is a complete
normed space).
| true |
ContextFreeGrammar.produces_reverse | Mathlib.Computability.ContextFreeGrammar | ∀ {T : Type u_1} {g : ContextFreeGrammar T} {u v : List (Symbol T g.NT)},
g.reverse.Produces u.reverse v.reverse ↔ g.Produces u v | null | true |
_private.Mathlib.RingTheory.Adjoin.Basic.0.Subalgebra.adjoin_eq_span_basis._simp_1_1 | Mathlib.RingTheory.Adjoin.Basic | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} (g : α → β) (f : ι → α), g '' Set.range f = Set.range (g ∘ f) | null | false |
_private.Init.Data.List.Lemmas.0.List.mem_map.match_1_1 | Init.Data.List.Lemmas | ∀ {α : Type u_1} (motive : List α → Prop) (x : List α),
(∀ (a : Unit), motive []) → (∀ (head : α) (l : List α), motive (head :: l)) → motive x | null | false |
CategoryTheory.Cat.HasLimits.limitCone._proof_2 | Mathlib.CategoryTheory.Category.Cat.Limit | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CategoryTheory.Cat) (j : J)
(X : CategoryTheory.Limits.limit (F.comp CategoryTheory.Cat.objects)),
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.Limits.limit.π (CategoryTheory.Cat.HasLimits.homDiagram X X) j))
(Categ... | null | false |
_private.Init.Data.SInt.Bitwise.0.Int8.or_eq_zero_iff._simp_1_1 | Init.Data.SInt.Bitwise | ∀ {a b : Int8}, (a = b) = (a.toBitVec = b.toBitVec) | null | false |
Std.DTreeMap.Internal.Impl.Const.alter._sunfold | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : Type v} →
[Ord α] →
α →
(Option β → Option β) →
(t : Std.DTreeMap.Internal.Impl α fun x => β) →
t.Balanced → Std.DTreeMap.Internal.Impl.SizedBalancedTree α (fun x => β) (t.size - 1) (t.size + 1) | null | false |
Sym2.card_toFinset | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} [inst : DecidableEq α] (z : Sym2 α), z.toFinset.card = if z.IsDiag then 1 else 2 | Mapping an unordered pair to a finite set produces a finset of size `1` if the pair is on the
diagonal, else of size `2` if the pair is off the diagonal. | true |
boolRingCatEquivBoolAlg | Mathlib.Algebra.Category.BoolRing | BoolRing ≌ BoolAlg | The equivalence between Boolean rings and Boolean algebras. This is actually an isomorphism. | true |
Cardinal.isSingular_aleph_iff | Mathlib.SetTheory.Cardinal.Regular | ∀ {o : Ordinal.{u_1}}, (Cardinal.aleph o).IsSingular ↔ Order.IsSuccLimit o ∧ o.cof < Cardinal.aleph o | null | true |
_private.Lean.Elab.Util.0.Lean.Elab.getBetterRef.match_1 | Lean.Elab.Util | (motive : Option Lean.Elab.MacroStackElem → Sort u_1) →
(x : Option Lean.Elab.MacroStackElem) →
((elem : Lean.Elab.MacroStackElem) → motive (some elem)) → (Unit → motive none) → motive x | null | false |
AffineSpace.vadd_asymptoticNhds | Mathlib.Topology.Algebra.AsymptoticCone | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Field k] [inst_1 : LinearOrder k] [inst_2 : AddCommGroup V]
[inst_3 : Module k V] [inst_4 : AddTorsor V P] [inst_5 : TopologicalSpace V] (u v : V),
u +ᵥ AffineSpace.asymptoticNhds k P v = AffineSpace.asymptoticNhds k P v | null | true |
_private.Mathlib.RingTheory.Coprime.Basic.0.IsCoprime.isUnit_of_dvd.match_1_1 | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {x y : R} (motive : x ∣ y → Prop) (d : x ∣ y),
(∀ (k : R) (hk : y = x * k), motive ⋯) → motive d | null | false |
Fin.div_val | Init.Data.Fin.Lemmas | ∀ {n : ℕ} (a b : Fin n), ↑(a / b) = ↑a / ↑b | null | true |
EuclideanSpace.inner_eq_star_dotProduct | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] [inst_1 : Fintype ι] (x y : EuclideanSpace 𝕜 ι),
inner 𝕜 x y = y.ofLp ⬝ᵥ star x.ofLp | null | true |
SubMulAction.instSetLike.eq_1 | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {R : Type u} {M : Type v} [inst : SMul R M],
SubMulAction.instSetLike = { coe := SubMulAction.carrier, coe_injective := ⋯ } | null | true |
_private.Init.Data.List.MapIdx.0.List.length_mapIdx_go._proof_1_6 | Init.Data.List.MapIdx | ∀ {α : Type u_1} {β : Type u_2} (l : List α) (x : Array β), ¬l.length + (x.size + 1) = l.length + 1 + x.size → False | null | false |
AlgebraicGeometry.Scheme.fromSpecResidueField | Mathlib.AlgebraicGeometry.ResidueField | (X : AlgebraicGeometry.Scheme) → (x : ↥X) → AlgebraicGeometry.Spec (X.residueField x) ⟶ X | The canonical map `Spec κ(x) ⟶ X`. | true |
subset_sInf_def | Mathlib.Order.CompleteLatticeIntervals | ∀ {α : Type u_2} (s : Set α) [inst : Preorder α] [inst_1 : InfSet α] [inst_2 : Inhabited ↑s],
sInf = fun t =>
if ht : t.Nonempty ∧ BddBelow t ∧ sInf (Subtype.val '' t) ∈ s then ⟨sInf (Subtype.val '' t), ⋯⟩ else default | null | true |
_private.Mathlib.SetTheory.Ordinal.Veblen.0.Ordinal.cmp_veblenWith.match_1.eq_1 | Mathlib.SetTheory.Ordinal.Veblen | ∀ (motive : Ordering → Sort u_1) (h_1 : Unit → motive Ordering.eq) (h_2 : Unit → motive Ordering.lt)
(h_3 : Unit → motive Ordering.gt),
(match Ordering.eq with
| Ordering.eq => h_1 ()
| Ordering.lt => h_2 ()
| Ordering.gt => h_3 ()) =
h_1 () | null | true |
Std.ExtTreeMap.maxKeyD_insert | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β} {fallback : α},
(t.insert k v).maxKeyD fallback = t.maxKey?.elim k fun k' => if (cmp k' k).isLE = true then k else k' | null | true |
FreeAddMagma.below | Mathlib.Algebra.Free | {α : Type u} → {motive : FreeAddMagma α → Sort u_1} → FreeAddMagma α → Sort (max (u + 1) u_1) | null | false |
Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVPred.boolAtom | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred | Lean.Expr → Lean.Elab.Tactic.BVDecide.Frontend.M (Option Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVPred) | Construct an uninterpreted `Bool` atom from `origExpr`.
| true |
_private.Mathlib.Analysis.Complex.PhragmenLindelof.0.PhragmenLindelof.eqOn_right_half_plane_of_superexponential_decay._simp_1_1 | Mathlib.Analysis.Complex.PhragmenLindelof | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
Subsemiring.nonneg._proof_1 | Mathlib.Algebra.Ring.Subsemiring.Order | ∀ (R : Type u_1) [inst : Semiring R] [inst_1 : PartialOrder R] [IsOrderedRing R], AddLeftMono R | null | false |
MvPowerSeries.support_truncFinset_subset | Mathlib.RingTheory.MvPowerSeries.Trunc | ∀ {σ : Type u_1} {R : Type u_2} [inst : CommSemiring R] {s : Finset (σ →₀ ℕ)} (p : MvPowerSeries σ R),
((MvPowerSeries.truncFinset R s) p).support ⊆ s | null | true |
Array.popWhile._unsafe_rec | Init.Data.Array.Basic | {α : Type u} → (α → Bool) → Array α → Array α | null | false |
inf_le_inf | Mathlib.Order.Lattice | ∀ {α : Type u} [inst : SemilatticeInf α] {a b c d : α}, b ≤ a → d ≤ c → b ⊓ d ≤ a ⊓ c | null | true |
_private.Mathlib.RingTheory.Norm.Transitivity.0.Algebra.Norm.Transitivity.auxMat_blockTriangular._simp_1_2 | Mathlib.RingTheory.Norm.Transitivity | ∀ {a b : Prop}, (¬(a → b)) = (a ∧ ¬b) | null | false |
IsCompact.isSigmaCompact | Mathlib.Topology.Compactness.SigmaCompact | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, IsCompact s → IsSigmaCompact s | Compact sets are σ-compact. | true |
List.alternatingProd_cons_cons' | Mathlib.Algebra.BigOperators.Group.List.Basic | ∀ {G : Type u_7} [inst : One G] [inst_1 : Mul G] [inst_2 : Inv G] (a b : G) (l : List G),
(a :: b :: l).alternatingProd = a * b⁻¹ * l.alternatingProd | null | true |
CategoryTheory.Sigma.natIso_inv | Mathlib.CategoryTheory.Sigma.Basic | ∀ {I : Type w₁} {C : I → Type u₁} [inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] {q₁ q₂ : CategoryTheory.Functor ((i : I) × C i) D}
(h : (i : I) → (CategoryTheory.Sigma.incl i).comp q₁ ≅ (CategoryTheory.Sigma.incl i).comp q₂),
(CategoryTheory.... | null | true |
AlgebraicGeometry.mono_pushoutSection_of_isCompact_of_flat_left_of_ringHomFlat | Mathlib.AlgebraicGeometry.Morphisms.Flat | ∀ {X Y S T : AlgebraicGeometry.Scheme} {f : T ⟶ S} {g : Y ⟶ X} {iX : X ⟶ S} {iY : Y ⟶ T}
(H : CategoryTheory.IsPullback g iY iX f) {US : S.Opens} {UT : T.Opens} {UX : X.Opens}
(hUST : UT ≤ (TopologicalSpace.Opens.map f.base).obj US) (hUSX : UX ≤ (TopologicalSpace.Opens.map iX.base).obj US)
{UY : Y.Opens} (hUY : U... | null | true |
HasFDerivWithinAt.of_insert | Mathlib.Analysis.Calculus.FDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F} {f' : E →L[𝕜] F} {x : E} {s : Set E} {y : E},
HasFDerivWith... | null | true |
CategoryTheory.MorphismProperty.isStableUnderTransfiniteCompositionOfShape_iff | Mathlib.CategoryTheory.MorphismProperty.TransfiniteComposition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C) (J : Type w)
[inst_1 : LinearOrder J] [inst_2 : SuccOrder J] [inst_3 : OrderBot J] [inst_4 : WellFoundedLT J],
W.IsStableUnderTransfiniteCompositionOfShape J ↔ W.transfiniteCompositionsOfShape J ≤ W | null | true |
_private.Init.Grind.Ring.CommSolver.0.Lean.Grind.CommRing.Stepwise.imp_1eq._simp_1_3 | Init.Grind.Ring.CommSolver | ∀ {M : Type u} [inst : Lean.Grind.AddCommGroup M] {a b : M}, (a - b = 0) = (a = b) | null | false |
NonUnitalRingHom.snd_comp_prod | Mathlib.Algebra.Ring.Prod | ∀ {R : Type u_1} {S : Type u_3} {T : Type u_5} [inst : NonUnitalNonAssocSemiring R]
[inst_1 : NonUnitalNonAssocSemiring S] [inst_2 : NonUnitalNonAssocSemiring T] (f : R →ₙ+* S) (g : R →ₙ+* T),
(NonUnitalRingHom.snd S T).comp (f.prod g) = g | null | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_492 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | null | false |
isCompact_setOf_finiteMeasure_le_of_isCompact | Mathlib.MeasureTheory.Measure.Prokhorov | ∀ {E : Type u_1} [inst : MeasurableSpace E] [inst_1 : TopologicalSpace E] [T2Space E] [inst_3 : BorelSpace E]
(C : NNReal) {K : Set E}, IsCompact K → IsCompact {μ | μ.mass ≤ C ∧ μ Kᶜ = 0} | The set of finite measures of mass at most `C` supported on a given compact set `K` is
compact. | true |
Algebra.algebraMapSubmonoid_self | Mathlib.Algebra.Algebra.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Submonoid R), Algebra.algebraMapSubmonoid R M = M | null | true |
MeasureTheory.isFiniteMeasure_toFiniteAux | Mathlib.MeasureTheory.Measure.WithDensityFinite | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : MeasureTheory.SFinite μ],
MeasureTheory.IsFiniteMeasure μ.toFiniteAux | null | true |
CategoryTheory.Abelian.SpectralObject.shortComplexMap._proof_26 | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_2} {ι : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) {i' j' k' l' : ι}
(f₁' : i' ⟶ j') (f₂' : j' ⟶ k') (... | null | false |
Lean.instInhabitedVersoDocString.default | Lean.DocString.Extension | Lean.VersoDocString | null | true |
CategoryTheory.Limits.ImageFactorisation.mk | Mathlib.CategoryTheory.Limits.Shapes.Images | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{f : X ⟶ Y} →
(F : CategoryTheory.Limits.MonoFactorisation f) →
CategoryTheory.Limits.IsImage F → CategoryTheory.Limits.ImageFactorisation f | null | true |
List.head_cons | Init.Data.List.Basic | ∀ {α : Type u} {a : α} {l : List α} {h : a :: l ≠ []}, (a :: l).head h = a | null | true |
_private.Mathlib.MeasureTheory.MeasurableSpace.Constructions.0.measurable_from_prod_countable_left'._simp_1_1 | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) | null | false |
Std.DHashMap.instForInSigmaOfMonad | Std.Data.DHashMap.Basic | {α : Type u} →
{β : α → Type v} →
{m : Type w → Type w'} →
[Monad m] → [inst : BEq α] → [inst_1 : Hashable α] → ForIn m (Std.DHashMap α β) ((a : α) × β a) | null | true |
ThreeGPFree.of_image | Mathlib.Combinatorics.Additive.AP.Three.Defs | ∀ {α : Type u_2} {β : Type u_3} [inst : CommMonoid α] [inst_1 : CommMonoid β] {s A : Set α} {t : Set β} {f : α → β},
IsMulFreimanHom 2 s t f → Set.InjOn f s → A ⊆ s → ThreeGPFree (f '' A) → ThreeGPFree A | Geometric progressions of length three are reflected under `2`-Freiman homomorphisms. | true |
AddSubmonoid.pi | Mathlib.Algebra.Group.Submonoid.Operations | {ι : Type u_4} →
{M : ι → Type u_5} →
[inst : (i : ι) → AddZeroClass (M i)] → Set ι → ((i : ι) → AddSubmonoid (M i)) → AddSubmonoid ((i : ι) → M i) | A version of `Set.pi` for `AddSubmonoid`s. Given an index set `I` and a family
of submodules `s : Π i, AddSubmonoid f i`, `pi I s` is the `AddSubmonoid` of dependent functions
`f : Π i, f i` such that `f i` belongs to `pi I s` whenever `i ∈ I`. | true |
_private.Mathlib.Algebra.Order.BigOperators.GroupWithZero.List.0.List.one_le_prod._simp_1_2 | Mathlib.Algebra.Order.BigOperators.GroupWithZero.List | ∀ {α : Sort u_1} {a' : α} {P Q : α → Prop}, (∀ (a : α), a = a' ∨ Q a → P a) = (P a' ∧ ∀ (a : α), Q a → P a) | null | false |
Std.Tactic.BVDecide.BVExpr.bitblast.FullAdderOutput.aig | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{old : Std.Sat.AIG α} → Std.Tactic.BVDecide.BVExpr.bitblast.FullAdderOutput old → Std.Sat.AIG α | null | true |
_private.Lean.Parser.Module.0.Lean.Parser.parseCommand.match_1 | Lean.Parser.Module | (motive : Option Lean.Parser.Error → Sort u_1) →
(x : Option Lean.Parser.Error) →
(Unit → motive none) → ((errorMsg : Lean.Parser.Error) → motive (some errorMsg)) → motive x | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct.0.SSet.PtSimplex.RelStruct.refl._proof_5 | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | ∀ (n : ℕ) (i : Fin (n + 1)) (j : Fin (n + 1 + 1)), j.castSucc < i.succ.castSucc → j ≤ i.castSucc | null | false |
Lean.Meta.Simp.NormCastConfig.beta._default | Init.MetaTypes | Bool | null | false |
DiscreteMeasurableSpace.toMeasurableSub | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {α : Type u_1} [inst : MeasurableSpace α] [inst_1 : Sub α] [DiscreteMeasurableSpace α], MeasurableSub α | null | true |
CoalgCat.concreteCategory._proof_1 | Mathlib.Algebra.Category.CoalgCat.Basic | ∀ {R : Type u_2} [inst : CommRing R] {X Y : CoalgCat R} (f : ↑X.toModuleCat →ₗc[R] ↑Y.toModuleCat),
{ toCoalgHom' := f }.toCoalgHom' = f | null | false |
Submonoid.mem_map_iff_mem | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_4} [inst_2 : FunLike F M N]
[mc : MonoidHomClass F M N] {f : F},
Function.Injective ⇑f → ∀ {S : Submonoid M} {x : M}, f x ∈ Submonoid.map f S ↔ x ∈ S | null | true |
_private.Std.Http.Data.URI.Encoding.0.Std.Http.URI.isHexDigit_isEncodedChar | Std.Http.Data.URI.Encoding | ∀ {r : UInt8 → Bool} {c : UInt8}, Std.Http.Internal.Char.isHexDigitByte c = true → Std.Http.URI.isEncodedChar r c = true | null | true |
CategoryTheory.Limits.Sigma.reindex | Mathlib.CategoryTheory.Limits.Shapes.Products | {β : Type w} →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{γ : Type w'} →
(ε : β ≃ γ) →
(f : γ → C) →
[inst_1 : CategoryTheory.Limits.HasCoproduct f] →
[inst_2 : CategoryTheory.Limits.HasCoproduct (f ∘ ⇑ε)] → ∐ f ∘ ⇑ε ≅ ∐ f | Reindex a categorical coproduct via an equivalence of the index types. | true |
FundamentalGroupoid.map_obj_as | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (f : C(X, Y))
(x : FundamentalGroupoid X), ((FundamentalGroupoid.map f).obj x).as = f x.as | null | true |
ContinuousLinearMap.toNormedRing._proof_14 | Mathlib.Analysis.Normed.Operator.NormedSpace | ∀ {𝕜 : Type u_2} {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NontriviallyNormedField 𝕜]
[inst_2 : NormedSpace 𝕜 E] (n : ℕ), IntCast.intCast ↑n = ↑n | null | false |
Lean.Meta.Grind.InjectiveInfo.mk.noConfusion | Lean.Meta.Tactic.Grind.Types | {P : Sort u} →
{us : List Lean.Level} →
{α β h : Lean.Expr} →
{inv? : Option (Lean.Expr × Lean.Expr)} →
{us' : List Lean.Level} →
{α' β' h' : Lean.Expr} →
{inv?' : Option (Lean.Expr × Lean.Expr)} →
{ us := us, α := α, β := β, h := h, inv? := inv? } =
... | null | false |
GrpWithZero.groupWithZeroConcreteCategory._proof_3 | Mathlib.Algebra.Category.GrpWithZero | ∀ {X : GrpWithZero} (x : X.carrier), (CategoryTheory.CategoryStruct.id X) x = x | null | false |
Option.merge_eq_some_iff | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {o o' : Option α} {f : α → α → α} {a : α},
Option.merge f o o' = some a ↔
o = some a ∧ o' = none ∨ o = none ∧ o' = some a ∨ ∃ b c, o = some b ∧ o' = some c ∧ f b c = a | null | true |
_private.Mathlib.Data.List.Basic.0.List.erase_getElem._proof_1_31 | Mathlib.Data.List.Basic | ∀ {ι : Type u_1} [inst : BEq ι] [inst_1 : LawfulBEq ι] (a : ι) (l : List ι) (n : ℕ) (hi : n + 1 < (a :: l).length)
(w : ι),
(a == (a :: l)[n + 1]) = true →
¬-1 * ↑(List.count w (List.take (n + 1) (a :: l))) + ↑(if (l[n] == w) = true then 1 else 0) ≤ 0 →
¬-1 * ↑(List.count w ((a :: l).eraseIdx (n + 1))) + ... | null | false |
Units.mulLECancellable_val | Mathlib.Algebra.Order.Monoid.Unbundled.Units | ∀ {M : Type u_1} [inst : Monoid M] [inst_1 : LE M] [MulLeftMono M] (u : Mˣ), MulLECancellable ↑u | null | true |
CategoryTheory.Subobject.map_mk | Mathlib.CategoryTheory.Subobject.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {A X Y : C} (i : A ⟶ X) [inst_1 : CategoryTheory.Mono i]
(f : X ⟶ Y) [inst_2 : CategoryTheory.Mono f],
(CategoryTheory.Subobject.map f).obj (CategoryTheory.Subobject.mk i) =
CategoryTheory.Subobject.mk (CategoryTheory.CategoryStruct.comp i f) | null | true |
Std.Time.Duration.subHours | Std.Time.Duration | Std.Time.Duration → Std.Time.Hour.Offset → Std.Time.Duration | Subtracts an `Hour.Offset` from a `Duration`
| true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.