name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Std.Internal.List.getValue?_insertEntry | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] [PartialEquivBEq α] {l : List ((_ : α) × β)} {k a : α} {v : β},
Std.Internal.List.getValue? a (Std.Internal.List.insertEntry k v l) =
if (k == a) = true then some v else Std.Internal.List.getValue? a l |
sSupHom.instSSupHomClass | Mathlib.Order.Hom.CompleteLattice | ∀ {α : Type u_2} {β : Type u_3} [inst : SupSet α] [inst_1 : SupSet β], sSupHomClass (sSupHom α β) α β |
DFinsupp.Colex.decidableLE | Mathlib.Data.DFinsupp.Lex | {ι : Type u_1} →
{α : ι → Type u_2} →
[inst : (i : ι) → Zero (α i)] →
[inst_1 : LinearOrder ι] → [inst_2 : (i : ι) → LinearOrder (α i)] → DecidableLE (Colex (Π₀ (i : ι), α i)) |
VectorFourier.norm_fourierIntegral_le_integral_norm | Mathlib.Analysis.Fourier.FourierTransform | ∀ {𝕜 : Type u_1} [inst : CommRing 𝕜] {V : Type u_2} [inst_1 : AddCommGroup V] [inst_2 : Module 𝕜 V]
[inst_3 : MeasurableSpace V] {W : Type u_3} [inst_4 : AddCommGroup W] [inst_5 : Module 𝕜 W] {E : Type u_4}
[inst_6 : NormedAddCommGroup E] [inst_7 : NormedSpace ℂ E] (e : AddChar 𝕜 Circle) (μ : MeasureTheory.Measure V)
(L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜) (f : V → E) (w : W), ‖VectorFourier.fourierIntegral e μ L f w‖ ≤ ∫ (v : V), ‖f v‖ ∂μ |
Ideal.Quotient.algebraMap_quotient_of_ramificationIdx_neZero | Mathlib.NumberTheory.RamificationInertia.Basic | ∀ {R : Type u} [inst : CommRing R] {S : Type v} [inst_1 : CommRing S] (p : Ideal R) (P : Ideal S) [inst_2 : Algebra R S]
[inst_3 : NeZero (Ideal.ramificationIdx (algebraMap R S) p P)] (x : R),
(algebraMap (R ⧸ p) (S ⧸ P)) ((Ideal.Quotient.mk p) x) = (Ideal.Quotient.mk P) ((algebraMap R S) x) |
QuotientAddGroup.equivIcoMod._proof_2 | Mathlib.Algebra.Order.ToIntervalMod | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [inst_2 : IsOrderedAddMonoid α] [hα : Archimedean α]
{p : α} (hp : 0 < p) (a : α) (b : α ⧸ AddSubgroup.zmultiples p), ⋯.lift b ∈ Set.Ico a (a + p) |
Lean.Compiler.LCNF.Check.Pure.State._sizeOf_inst | Lean.Compiler.LCNF.Check | SizeOf Lean.Compiler.LCNF.Check.Pure.State |
_private.Mathlib.Topology.UniformSpace.Defs.0.isOpen_uniformity._simp_1_2 | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type u_1} {β : Type u_2} {x : α} {s : Set β} {F : Filter (α × β)},
(s ∈ Filter.comap (Prod.mk x) F) = ({p | p.1 = x → p.2 ∈ s} ∈ F) |
Std.Rcc.isSome_succMany?_of_lt_length_toList | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rcc α} [inst : LE α] [inst_1 : DecidableLE α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLE α]
[inst_5 : Std.Rxc.IsAlwaysFinite α] {i : ℕ}, i < r.toList.length → (Std.PRange.succMany? i r.lower).isSome = true |
Multiset.rel_zero_right._simp_1 | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} {β : Type v} {r : α → β → Prop} {a : Multiset α}, Multiset.Rel r a 0 = (a = 0) |
_private.Batteries.Data.Array.Scan.0.Array.back?_scanr._simp_1_1 | Batteries.Data.Array.Scan | ∀ {α : Type u_1} (xs : Array α), xs.back? = xs.toList.getLast? |
Batteries.RBNode.del._unsafe_rec | Batteries.Data.RBMap.Basic | {α : Type u_1} → (α → Ordering) → Batteries.RBNode α → Batteries.RBNode α |
SimpleGraph.Subgraph.Preconnected.casesOn | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | {V : Type u} →
{G : SimpleGraph V} →
{H : G.Subgraph} →
{motive : H.Preconnected → Sort u_1} → (t : H.Preconnected) → ((coe : H.coe.Preconnected) → motive ⋯) → motive t |
ContinuousLinearMap.isBigOTVS_fun_comp | Mathlib.Analysis.Asymptotics.TVS | ∀ {α : Type u_1} {𝕜 : Type u_3} {E : Type u_4} {F : Type u_5} [inst : NontriviallyNormedField 𝕜]
[inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E] [inst_3 : Module 𝕜 E] [inst_4 : AddCommGroup F]
[inst_5 : TopologicalSpace F] [inst_6 : Module 𝕜 F] {l : Filter α} {f : α → E} (g : E →L[𝕜] F),
(fun x => g (f x)) =O[𝕜; l] f |
Lean.Meta.DefaultInstanceEntry.rec | Lean.Meta.Instances | {motive : Lean.Meta.DefaultInstanceEntry → Sort u} →
((className instanceName : Lean.Name) →
(priority : ℕ) → motive { className := className, instanceName := instanceName, priority := priority }) →
(t : Lean.Meta.DefaultInstanceEntry) → motive t |
_private.Mathlib.Algebra.Polynomial.Inductions.0.Polynomial.natDegree_divX_eq_natDegree_tsub_one._simp_1_2 | Mathlib.Algebra.Polynomial.Inductions | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, (p.divX = 0) = (p = Polynomial.C (p.coeff 0)) |
CategoryTheory.Bicategory.hom_inv_whiskerRight_whiskerRight_assoc | Mathlib.CategoryTheory.Bicategory.Basic | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c d : B} {f g : a ⟶ b} (η : f ≅ g) (h : b ⟶ c) (k : c ⟶ d)
{Z : a ⟶ d} (h_1 : CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f h) k ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (CategoryTheory.Bicategory.whiskerRight η.hom h) k)
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (CategoryTheory.Bicategory.whiskerRight η.inv h) k) h_1) =
h_1 |
Booleanisation.instBooleanAlgebra._proof_14 | Mathlib.Order.Booleanisation | ∀ {α : Type u_1} [inst : GeneralizedBooleanAlgebra α] (x : Booleanisation α), ⊤ ≤ x ⊔ xᶜ |
Finset.convexHull_eq | Mathlib.Analysis.Convex.Combination | ∀ {R : Type u_1} {E : Type u_3} [inst : Field R] [inst_1 : AddCommGroup E] [inst_2 : Module R E]
[inst_3 : LinearOrder R] [IsStrictOrderedRing R] (s : Finset E),
(convexHull R) ↑s = {x | ∃ w, (∀ y ∈ s, 0 ≤ w y) ∧ ∑ y ∈ s, w y = 1 ∧ s.centerMass w id = x} |
Submodule.prodEquivOfIsCompl_symm_apply_right | Mathlib.LinearAlgebra.Projection | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] (p q : Submodule R E)
(h : IsCompl p q) (x : ↥q), (p.prodEquivOfIsCompl q h).symm ↑x = (0, x) |
Mathlib.Tactic.Push.Head.noConfusionType | Mathlib.Tactic.Push.Attr | Sort u → Mathlib.Tactic.Push.Head → Mathlib.Tactic.Push.Head → Sort u |
biInf_sigma | Mathlib.Data.Set.Sigma | ∀ {ι : Type u_1} {α : ι → Type u_3} {β : Type u_4} [inst : CompleteLattice β] (s : Set ι) (t : (i : ι) → Set (α i))
(f : Sigma α → β), ⨅ ij ∈ s.sigma t, f ij = ⨅ i ∈ s, ⨅ j ∈ t i, f ⟨i, j⟩ |
ArchimedeanClass.mem_closedBall_iff | Mathlib.Algebra.Order.Module.Archimedean | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] (K : Type u_2)
[inst_3 : Ring K] [inst_4 : LinearOrder K] [inst_5 : IsOrderedRing K] [inst_6 : Archimedean K] [inst_7 : Module K M]
[inst_8 : PosSMulMono K M] {a : M} {c : ArchimedeanClass M},
a ∈ ArchimedeanClass.closedBall K c ↔ c ≤ ArchimedeanClass.mk a |
_private.Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis.0.AlgebraicIndependent.matroid_isBasis_iff._simp_1_2 | Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis | ∀ {R : Type u_1} {A : Type w} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
[inst_3 : FaithfulSMul R A] [inst_4 : NoZeroDivisors A] {s : Set A},
(AlgebraicIndependent.matroid R A).Indep s = AlgebraicIndepOn R id s |
Pi.addMonoidHom._proof_2 | Mathlib.Algebra.Group.Pi.Lemmas | ∀ {I : Type u_1} {f : I → Type u_2} {γ : Type u_3} [inst : (i : I) → AddZeroClass (f i)] [inst_1 : AddZeroClass γ]
(g : (i : I) → γ →+ f i) (x y : γ),
(Pi.addHom fun i => ↑(g i)).toFun (x + y) = (Pi.addHom fun i => ↑(g i)).toFun x + (Pi.addHom fun i => ↑(g i)).toFun y |
ContinuousMap.mem_nhds_iff | Mathlib.Topology.CompactOpen | ∀ {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : C(X, Y)}
{s : Set C(X, Y)},
s ∈ nhds f ↔
∃ S,
S.Finite ∧
(∀ (K : Set X) (U : Set Y), (K, U) ∈ S → IsCompact K ∧ IsOpen U ∧ Set.MapsTo (⇑f) K U) ∧
{g | ∀ (K : Set X) (U : Set Y), (K, U) ∈ S → Set.MapsTo (⇑g) K U} ⊆ s |
sub_one_div_inv_le_two | Mathlib.Algebra.Order.Field.Basic | ∀ {α : Type u_2} [inst : Field α] [inst_1 : PartialOrder α] [PosMulReflectLT α] [IsStrictOrderedRing α] {a : α},
2 ≤ a → (1 - 1 / a)⁻¹ ≤ 2 |
Lean.Linter.MissingDocs.checkSyntaxCat._regBuiltin.Lean.Linter.MissingDocs.checkSyntaxCat_1 | Lean.Linter.MissingDocs | IO Unit |
Lean.Doc.PostponedName.casesOn | Lean.Elab.DocString.Builtin.Postponed | {motive : Lean.Doc.PostponedName → Sort u} →
(t : Lean.Doc.PostponedName) → ((name : Lean.Name) → motive { name := name }) → motive t |
NumberField.mixedEmbedding.fundamentalCone.hasDerivAt_expMap_single | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | ∀ {K : Type u_1} [inst : Field K] (w : NumberField.InfinitePlace K) (x : ℝ),
HasDerivAt (↑(NumberField.mixedEmbedding.fundamentalCone.expMap_single w))
(NumberField.mixedEmbedding.fundamentalCone.deriv_expMap_single w x) x |
Std.DHashMap.Raw.Const.get_map' | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {γ : Type w} {m : Std.DHashMap.Raw α fun x => β}
[inst_2 : EquivBEq α] [inst_3 : LawfulHashable α] {f : α → β → γ} {k : α} {h' : k ∈ Std.DHashMap.Raw.map f m}
(h : m.WF),
Std.DHashMap.Raw.Const.get (Std.DHashMap.Raw.map f m) k h' = f (m.getKey k ⋯) (Std.DHashMap.Raw.Const.get m k ⋯) |
List.getElem?_iterate | Mathlib.Data.List.Iterate | ∀ {α : Type u_1} (f : α → α) (a : α) (n i : ℕ), i < n → (List.iterate f a n)[i]? = some (f^[i] a) |
Finset.traverse.eq_1 | Mathlib.Data.Finset.Functor | ∀ {α β : Type u} {F : Type u → Type u} [inst : Applicative F] [inst_1 : CommApplicative F] [inst_2 : DecidableEq β]
(f : α → F β) (s : Finset α), Finset.traverse f s = Multiset.toFinset <$> Multiset.traverse f s.val |
MeasureTheory.FiniteMeasure.instModuleNNReal | Mathlib.MeasureTheory.Measure.FiniteMeasure | {Ω : Type u_3} → [inst : MeasurableSpace Ω] → Module NNReal (MeasureTheory.FiniteMeasure Ω) |
CoeFun.recOn | Init.Coe | {α : Sort u} →
{γ : α → Sort v} →
{motive : CoeFun α γ → Sort u_1} → (t : CoeFun α γ) → ((coe : (f : α) → γ f) → motive { coe := coe }) → motive t |
Lean.Compiler.LCNF.Decl.isTemplateLike | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.Decl pu → Lean.CoreM Bool |
IsLocalExtr.comp_continuous | Mathlib.Topology.Order.LocalExtr | ∀ {α : Type u} {β : Type v} {δ : Type x} [inst : TopologicalSpace α] [inst_1 : Preorder β] {f : α → β}
[inst_2 : TopologicalSpace δ] {g : δ → α} {b : δ}, IsLocalExtr f (g b) → ContinuousAt g b → IsLocalExtr (f ∘ g) b |
Matroid.IsBasis.subset_closure | Mathlib.Combinatorics.Matroid.Closure | ∀ {α : Type u_2} {M : Matroid α} {X I : Set α}, M.IsBasis I X → X ⊆ M.closure I |
_private.Mathlib.LinearAlgebra.TensorProduct.Pi.0.TensorProduct.piScalarRightInv._proof_3 | Mathlib.LinearAlgebra.TensorProduct.Pi | ∀ (R : Type u_1) [inst : CommSemiring R] (S : Type u_4) [inst_1 : CommSemiring S] (N : Type u_2)
[inst_2 : AddCommMonoid N] [inst_3 : Module R N] [inst_4 : Module S N] (ι : Type u_3) [inst_5 : DecidableEq ι] (i : ι)
(x : S) (x_1 : N), (x • x_1) ⊗ₜ[R] Pi.single i 1 = (x • x_1) ⊗ₜ[R] Pi.single i 1 |
IsDiscrete.preimage' | Mathlib.Topology.DiscreteSubset | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {s : Set Y},
IsDiscrete s → ContinuousOn f (f ⁻¹' s) → (∀ (x : Y), IsDiscrete (f ⁻¹' {x})) → IsDiscrete (f ⁻¹' s) |
_private.Mathlib.Data.Nat.GCD.Basic.0.Nat.coprime_iff_isRelPrime._simp_1_5 | Mathlib.Data.Nat.GCD.Basic | ∀ {α : Type u_1} [inst : CommMonoid α] {x : α}, IsUnit x = (x ∣ 1) |
NonUnitalSubring.add_mem | Mathlib.RingTheory.NonUnitalSubring.Defs | ∀ {R : Type u} [inst : NonUnitalNonAssocRing R] (s : NonUnitalSubring R) {x y : R}, x ∈ s → y ∈ s → x + y ∈ s |
SSet.Truncated.HomotopyCategory₂._sizeOf_1 | Mathlib.AlgebraicTopology.Quasicategory.TwoTruncated | {A : SSet.Truncated 2} → A.HomotopyCategory₂ → ℕ |
SimpleGraph.IsClique.mono | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} {G H : SimpleGraph α} {s : Set α}, G ≤ H → G.IsClique s → H.IsClique s |
MonCat | Mathlib.Algebra.Category.MonCat.Basic | Type (u + 1) |
Topology.CWComplex.instRelCWComplex._proof_3 | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] (C : Set X) [inst_1 : Topology.CWComplex C] (n : ℕ)
(i : Topology.CWComplex.cell C n),
∃ I,
Set.MapsTo (↑(Topology.CWComplex.map n i)) (Metric.sphere 0 1)
(∅ ∪ ⋃ m, ⋃ (_ : m < n), ⋃ j ∈ I m, ↑(Topology.CWComplex.map m j) '' Metric.closedBall 0 1) |
Lean.Grind.CommRing.Poly.checkCoeffs._unsafe_rec | Lean.Meta.Tactic.Grind.Arith.CommRing.Poly | Lean.Grind.CommRing.Poly → Bool |
EuclideanDomain.remainder | Mathlib.Algebra.EuclideanDomain.Defs | {R : Type u} → [self : EuclideanDomain R] → R → R → R |
UInt64.lt_irrefl | Init.Data.UInt.Lemmas | ∀ (a : UInt64), ¬a < a |
RootPairing.Base.mk._flat_ctor | Mathlib.LinearAlgebra.RootSystem.Base | {ι : 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} →
(support : Finset ι) →
LinearIndepOn R ⇑P.root ↑support →
LinearIndepOn R ⇑P.coroot ↑support →
(∀ (i : ι),
P.root i ∈ AddSubmonoid.closure (⇑P.root '' ↑support) ∨
-P.root i ∈ AddSubmonoid.closure (⇑P.root '' ↑support)) →
(∀ (i : ι),
P.coroot i ∈ AddSubmonoid.closure (⇑P.coroot '' ↑support) ∨
-P.coroot i ∈ AddSubmonoid.closure (⇑P.coroot '' ↑support)) →
P.Base |
_private.Mathlib.Algebra.Homology.CochainComplexOpposite.0.CochainComplex.homotopyUnop._proof_5 | Mathlib.Algebra.Homology.CochainComplexOpposite | ∀ (q q' : ℤ), q = q' → ComplexShape.embeddingUpIntDownInt.f q = ComplexShape.embeddingUpIntDownInt.f q' |
lie_eq_smul | Mathlib.Algebra.Lie.OfAssociative | ∀ {A : Type v} [inst : Ring A] {M : Type w} [inst_1 : AddCommGroup M] [inst_2 : Module A M] (a : A) (m : M),
⁅a, m⁆ = a • m |
CategoryTheory.Coyoneda.punitIso | Mathlib.CategoryTheory.Yoneda | CategoryTheory.coyoneda.obj (Opposite.op PUnit.{v₁ + 1}) ≅ CategoryTheory.Functor.id (Type v₁) |
_private.Lean.Meta.MatchUtil.0.Lean.Meta.matchHelper?.match_1 | Lean.Meta.MatchUtil | {α : Type} →
(motive : Option α → Sort u_1) →
(__do_lift : Option α) → (Unit → motive none) → ((s : Option α) → motive s) → motive __do_lift |
List.getElem_cons_length | Init.Data.List.Lemmas | ∀ {α : Type u_1} {x : α} {xs : List α} {i : ℕ} (h : i = xs.length), (x :: xs)[i] = (x :: xs).getLast ⋯ |
CategoryTheory.Functor.FullyFaithful.hasShift.map_zero_inv_app | Mathlib.CategoryTheory.Shift.Basic | ∀ {C : Type u} {A : Type u_1} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_1, u_2} D] [inst_2 : AddMonoid A] [inst_3 : CategoryTheory.HasShift D A]
{F : CategoryTheory.Functor C D} (hF : F.FullyFaithful) (s : A → CategoryTheory.Functor C C)
(i : (i : A) → (s i).comp F ≅ F.comp (CategoryTheory.shiftFunctor D i)) (X : C),
F.map ((CategoryTheory.Functor.FullyFaithful.hasShift.zero hF s i).inv.app X) =
CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctorZero D A).inv.app (F.obj X)) ((i 0).inv.app X) |
String.Pos.Raw.isValid.eq_def | Init.Data.String.Basic | ∀ (s : String) (p : String.Pos.Raw),
String.Pos.Raw.isValid s p =
if h : p < s.rawEndPos then decide (s.getUTF8Byte p h).IsUTF8FirstByte else decide (p = s.rawEndPos) |
UInt64.lt_trans | Init.Data.UInt.Lemmas | ∀ {a b c : UInt64}, a < b → b < c → a < c |
_private.Mathlib.Computability.NFA.0.NFA.mem_evalFrom_iff_nonempty_path.match_1_7 | Mathlib.Computability.NFA | ∀ {α : Type u_1} {σ : Type u_2} {M : NFA α σ} (motive : (x : List α) → (t s : σ) → Nonempty (M.Path s t x) → Prop)
(x : List α) (t s : σ) (p : Nonempty (M.Path s t x)),
(∀ (s : σ), motive [] s s ⋯) →
(∀ (t s s' : σ) (a : α) (x : List α) (h₁ : s' ∈ M.step s a) (h₂ : M.Path s' t x), motive (a :: x) t s ⋯) →
motive x t s p |
Representation.Coinvariants.induction_on | Mathlib.RepresentationTheory.Coinvariants | ∀ {k : Type u_1} {G : Type u_2} {V : Type u_3} [inst : CommRing k] [inst_1 : Monoid G] [inst_2 : AddCommGroup V]
[inst_3 : Module k V] {ρ : Representation k G V} {motive : ρ.Coinvariants → Prop} (x : ρ.Coinvariants),
(∀ (v : V), motive ((Representation.Coinvariants.mk ρ) v)) → motive x |
CochainComplex.HomComplex.Cochain.rightUnshift_comp._proof_2 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | ∀ {n m a nm : ℤ}, n + m = nm → ∀ (nm' : ℤ), nm + a = nm' → ∀ (m' : ℤ), m + a = m' → n + m' = nm' |
CentroidHom.coe_neg | Mathlib.Algebra.Ring.CentroidHom | ∀ {α : Type u_5} [inst : NonUnitalNonAssocRing α] (f : CentroidHom α), ⇑(-f) = -⇑f |
Subtype.coe_eq_iff | Mathlib.Data.Subtype | ∀ {α : Sort u_1} {p : α → Prop} {a : { a // p a }} {b : α}, ↑a = b ↔ ∃ (h : p b), a = ⟨b, h⟩ |
Std.Roo.size | Init.Data.Range.Polymorphic.Iterators | {α : Type u} → [Std.Rxo.HasSize α] → [Std.PRange.UpwardEnumerable α] → Std.Roo α → ℕ |
_private.Mathlib.Topology.UniformSpace.Cauchy.0.UniformSpace.secondCountable_of_separable._simp_3 | Mathlib.Topology.UniformSpace.Cauchy | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) |
Equiv.distribMulAction._proof_2 | Mathlib.Algebra.GroupWithZero.Action.TransferInstance | ∀ (M : Type u_2) {A : Type u_1} {B : Type u_3} (e : A ≃ B) [inst : Monoid M] [inst_1 : AddMonoid B]
[inst_2 : DistribMulAction M B] (a : M), a • 0 = 0 |
DistLat.instConcreteCategoryLatticeHomCarrier._proof_4 | Mathlib.Order.Category.DistLat | ∀ {X Y Z : DistLat} (f : X ⟶ Y) (g : Y ⟶ Z) (x : ↑X),
(CategoryTheory.CategoryStruct.comp f g).hom' x = g.hom' (f.hom' x) |
Finsupp.embDomain_zero | Mathlib.Data.Finsupp.Defs | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_4} [inst : Zero M] (f : α ↪ β), Finsupp.embDomain f 0 = 0 |
CategoryTheory.CatCommSq.iso | Mathlib.CategoryTheory.CatCommSq | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{C₃ : Type u_3} →
{C₄ : Type u_4} →
{inst : CategoryTheory.Category.{v_1, u_1} C₁} →
{inst_1 : CategoryTheory.Category.{v_2, u_2} C₂} →
{inst_2 : CategoryTheory.Category.{v_3, u_3} C₃} →
{inst_3 : CategoryTheory.Category.{v_4, u_4} C₄} →
(T : CategoryTheory.Functor C₁ C₂) →
(L : CategoryTheory.Functor C₁ C₃) →
(R : CategoryTheory.Functor C₂ C₄) →
(B : CategoryTheory.Functor C₃ C₄) →
[self : CategoryTheory.CatCommSq T L R B] → T.comp R ≅ L.comp B |
TemperedDistribution.instLineDeriv | Mathlib.Analysis.Distribution.TemperedDistribution | {E : Type u_3} →
{F : Type u_4} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedAddCommGroup F] →
[inst_2 : NormedSpace ℝ E] →
[inst_3 : NormedSpace ℂ F] → LineDeriv E (TemperedDistribution E F) (TemperedDistribution E F) |
CategoryTheory.effectiveEpiFamily_of_effectiveEpi_epi_comp | Mathlib.CategoryTheory.EffectiveEpi.Comp | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {α : Type u_2} {B : C} {X Y : α → C}
(f : (a : α) → X a ⟶ B) (g : (a : α) → Y a ⟶ X a) [∀ (a : α), CategoryTheory.Epi (g a)]
[CategoryTheory.EffectiveEpiFamily Y fun a => CategoryTheory.CategoryStruct.comp (g a) (f a)],
CategoryTheory.EffectiveEpiFamily X f |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.eqImp | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.Code pu → Lean.Compiler.LCNF.Code pu → Bool |
Graph.IsClosedSubgraph.rfl | Mathlib.Combinatorics.Graph.Subgraph | ∀ {α : Type u_1} {β : Type u_2} {G : Graph α β}, G.IsClosedSubgraph G |
AffineIsometryEquiv.pointReflection_midpoint_right | Mathlib.Analysis.Normed.Affine.Isometry | ∀ {V : Type u_2} {P : Type u_10} [inst : SeminormedAddCommGroup V] [inst_1 : PseudoMetricSpace P]
[inst_2 : NormedAddTorsor V P] [inst_3 : NormedSpace ℝ V] (x y : P),
(AffineIsometryEquiv.pointReflection ℝ (midpoint ℝ x y)) y = x |
_private.Lean.Meta.Tactic.Contradiction.0.Lean.Meta.processGenDiseq.match_7 | Lean.Meta.Tactic.Contradiction | (motive : Option (Option Lean.Expr) → Sort u_1) →
(x : Option (Option Lean.Expr)) → (Unit → motive none) → ((a : Option Lean.Expr) → motive (some a)) → motive x |
Nat.gcd_pos_of_pos_left | Init.Data.Nat.Gcd | ∀ {m : ℕ} (n : ℕ), 0 < m → 0 < m.gcd n |
FinEnum.recEmptyOption.eq_def | Mathlib.Data.FinEnum.Option | ∀ {P : Type u → Sort v} (finChoice : (n : ℕ) → Fin (n + 1))
(congr : {α β : Type u} → (x : FinEnum α) → (x_1 : FinEnum β) → FinEnum.card β = FinEnum.card α → P α → P β)
(empty : P PEmpty.{u + 1}) (option : {α : Type u} → FinEnum α → P α → P (Option α)) (α : Type u) [inst : FinEnum α],
FinEnum.recEmptyOption finChoice congr empty option α =
match cardeq : FinEnum.card α with
| 0 => congr FinEnum.pempty inst cardeq empty
| n.succ =>
let fN := ULift.instFinEnum;
have this := ⋯;
congr (FinEnum.insertNone (ULift.{u, 0} (Fin n)) ↑↑(finChoice n)) inst ⋯
(option fN
(FinEnum.recEmptyOption finChoice (fun {α β} => congr) empty (fun {α} => option) (ULift.{u, 0} (Fin n)))) |
TopologicalSpace.indiscrete_iff_forall_inseparable | Mathlib.Topology.Order | ∀ {α : Type u} {t : TopologicalSpace α}, IndiscreteTopology α ↔ ∀ (x y : α), Inseparable x y |
FreeAbelianGroup.nonUnitalNonAssocRing._proof_15 | Mathlib.GroupTheory.FreeAbelianGroup | ∀ {α : Type u_1} [inst : Mul α] (x : FreeAbelianGroup α), x * 0 = x * 0 |
CategoryTheory.JointlyFaithful.jointlyReflectsIsomorphisms | Mathlib.CategoryTheory.Functor.ReflectsIso.Jointly | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {I : Type u_2} {D : I → Type u_3}
[inst_1 : (i : I) → CategoryTheory.Category.{u_5, u_3} (D i)] {F : (i : I) → CategoryTheory.Functor C (D i)}
[CategoryTheory.Balanced C], CategoryTheory.JointlyFaithful F → CategoryTheory.JointlyReflectIsomorphisms F |
CliffordAlgebra.contractLeft._proof_4 | Mathlib.LinearAlgebra.CliffordAlgebra.Contraction | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{Q : QuadraticForm R M} (d₁ d₂ : Module.Dual R M) (v : M) (x fx : CliffordAlgebra Q),
((CliffordAlgebra.contractLeftAux Q (d₁ + d₂)) v)
((CliffordAlgebra.ι Q) v * x, ((CliffordAlgebra.contractLeftAux Q (d₁ + d₂)) v) (x, fx)) =
Q v • fx |
SheafOfModules.relationsOfIsCokernelFree_I | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} [inst_1 : CategoryTheory.HasSheafify J AddCommGrpCat]
[inst_2 : J.WEqualsLocallyBijective AddCommGrpCat]
[inst_3 : J.HasSheafCompose (CategoryTheory.forget₂ RingCat AddCommGrpCat)] {ι σ : Type u} {M : SheafOfModules R}
(f : SheafOfModules.free ι ⟶ SheafOfModules.free σ) (g : SheafOfModules.free σ ⟶ M)
(H : CategoryTheory.CategoryStruct.comp f g = 0)
(H' : CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.CokernelCofork.ofπ g H)),
(SheafOfModules.relationsOfIsCokernelFree f g H H').I = ι |
PowerSeries.HasSubst.smul_X' | Mathlib.RingTheory.PowerSeries.Substitution | ∀ {A : Type u_1} [inst : CommRing A] {R : Type u_2} [inst_1 : CommRing R] [inst_2 : Algebra A R] (a : A),
PowerSeries.HasSubst (a • PowerSeries.X) |
Lean.Meta.instMonadMetaM | Lean.Meta.Basic | Monad Lean.MetaM |
Set.injOn_subtype_val | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {p : α → Prop} {s : Set { x // p x }}, Set.InjOn Subtype.val s |
Std.Iter.atIdxSlow?._proof_8 | Init.Data.Iterators.Consumers.Access | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] (it : Std.Iter β) (n : (fun x => ℕ) it) (it' : Std.Iter β),
it.IsPlausibleStep (Std.IterStep.skip it') →
InvImage (Prod.Lex WellFoundedRelation.rel Std.IterM.TerminationMeasures.Productive.Rel)
(fun p => (p.snd, p.fst.finitelyManySkips!)) ⟨it', n⟩ ⟨it, n⟩ |
Array.getElem_set_self | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α} {i : ℕ} (h : i < xs.size) {v : α}, (xs.set i v h)[i] = v |
Batteries.Tactic.Alias.AliasInfo.forward.elim | Batteries.Tactic.Alias | {motive : Batteries.Tactic.Alias.AliasInfo → Sort u} →
(t : Batteries.Tactic.Alias.AliasInfo) →
t.ctorIdx = 1 → ((n : Lean.Name) → motive (Batteries.Tactic.Alias.AliasInfo.forward n)) → motive t |
UniformSpace.noConfusion | Mathlib.Topology.UniformSpace.Defs | {P : Sort u_1} →
{α : Type u} →
{t : UniformSpace α} →
{α' : Type u} → {t' : UniformSpace α'} → α = α' → t ≍ t' → UniformSpace.noConfusionType P t t' |
CategoryTheory.ModObj.assoc_flip | Mathlib.CategoryTheory.Monoidal.Mod_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D]
{M : C} [inst_4 : CategoryTheory.MonObj M] (X : D) [inst_5 : CategoryTheory.ModObj M X],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionHomRight M CategoryTheory.ModObj.smul)
CategoryTheory.ModObj.smul =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionAssocIso M M X).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionHomLeft CategoryTheory.MonObj.mul X)
CategoryTheory.ModObj.smul) |
Filter.Tendsto.isCompact_insert_range | Mathlib.Topology.Compactness.Compact | ∀ {X : Type u} [inst : TopologicalSpace X] {f : ℕ → X} {x : X},
Filter.Tendsto f Filter.atTop (nhds x) → IsCompact (insert x (Set.range f)) |
Mathlib.Tactic.BicategoryLike.StructuralAtom.rec | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {motive : Mathlib.Tactic.BicategoryLike.StructuralAtom → Sort u} →
((e : Lean.Expr) →
(f g h : Mathlib.Tactic.BicategoryLike.Mor₁) →
motive (Mathlib.Tactic.BicategoryLike.StructuralAtom.associator e f g h)) →
((e : Lean.Expr) →
(f : Mathlib.Tactic.BicategoryLike.Mor₁) →
motive (Mathlib.Tactic.BicategoryLike.StructuralAtom.leftUnitor e f)) →
((e : Lean.Expr) →
(f : Mathlib.Tactic.BicategoryLike.Mor₁) →
motive (Mathlib.Tactic.BicategoryLike.StructuralAtom.rightUnitor e f)) →
((e : Lean.Expr) →
(f : Mathlib.Tactic.BicategoryLike.Mor₁) → motive (Mathlib.Tactic.BicategoryLike.StructuralAtom.id e f)) →
((α : Mathlib.Tactic.BicategoryLike.CoherenceHom) →
motive (Mathlib.Tactic.BicategoryLike.StructuralAtom.coherenceHom α)) →
(t : Mathlib.Tactic.BicategoryLike.StructuralAtom) → motive t |
CochainComplex.ConnectData.X | Mathlib.Algebra.Homology.Embedding.Connect | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] → ChainComplex C ℕ → CochainComplex C ℕ → ℤ → C |
Monotone.ae_differentiableAt | Mathlib.Analysis.Calculus.Monotone | ∀ {f : ℝ → ℝ}, Monotone f → ∀ᵐ (x : ℝ), DifferentiableAt ℝ f x |
AList.lookup.eq_1 | Mathlib.Data.List.AList | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] (a : α) (s : AList β),
AList.lookup a s = List.dlookup a s.entries |
_private.Mathlib.Analysis.Calculus.DSlope.0.differentiableAt_dslope_of_ne._simp_1_1 | Mathlib.Analysis.Calculus.DSlope | ∀ {𝕜 : 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} {x : E}, DifferentiableAt 𝕜 f x = DifferentiableWithinAt 𝕜 f Set.univ x |
Lean.Lsp.DidSaveTextDocumentParams | Lean.Data.Lsp.TextSync | Type |
Complex.sin_sub_nat_mul_two_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℂ) (n : ℕ), Complex.sin (x - ↑n * (2 * ↑Real.pi)) = Complex.sin x |
BitVec.DivModState.recOn | Init.Data.BitVec.Bitblast | {w : ℕ} →
{motive : BitVec.DivModState w → Sort u} →
(t : BitVec.DivModState w) →
((wn wr : ℕ) → (q r : BitVec w) → motive { wn := wn, wr := wr, q := q, r := r }) → motive t |
_private.Mathlib.Combinatorics.Quiver.SingleObj.0.Quiver.SingleObj.toPrefunctor_symm_comp._simp_1_1 | Mathlib.Combinatorics.Quiver.SingleObj | ∀ {α : Sort u_1} {β : Sort u_2} (e : α ≃ β) {x : β} {y : α}, (e.symm x = y) = (x = e y) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.