name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Batteries.Tactic.exacts | Batteries.Tactic.Init | Lean.ParserDescr | Like `exact`, but takes a list of terms and checks that all goals are discharged after the tactic.
| true |
KaehlerDifferential.derivationQuotKerTotal | Mathlib.RingTheory.Kaehler.Basic | (R : Type u) →
(S : Type v) →
[inst : CommRing R] →
[inst_1 : CommRing S] → [inst_2 : Algebra R S] → Derivation R S ((S →₀ S) ⧸ KaehlerDifferential.kerTotal R S) | The (universal) derivation into `(S →₀ S) ⧸ KaehlerDifferential.kerTotal R S`. | true |
Matrix.IsAdjMatrix.submatrix | Mathlib.Combinatorics.SimpleGraph.AdjMatrix | ∀ {α : Type u_1} {V : Type u_2} {W : Type u_3} {A : Matrix V V α} [inst : Zero α] [inst_1 : One α],
A.IsAdjMatrix → ∀ (f : W → V), (A.submatrix f f).IsAdjMatrix | null | true |
Matroid.eRk_union_le_eRk_add_encard | Mathlib.Combinatorics.Matroid.Rank.ENat | ∀ {α : Type u_1} (M : Matroid α) (X Y : Set α), M.eRk (X ∪ Y) ≤ M.eRk X + Y.encard | null | true |
Std.ExtDTreeMap.Const.get!_diff | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t₁ t₂ : Std.ExtDTreeMap α (fun x => β) cmp}
[inst : Std.TransCmp cmp] [inst_1 : Inhabited β] {k : α},
Std.ExtDTreeMap.Const.get! (t₁ \ t₂) k = if k ∈ t₂ then default else Std.ExtDTreeMap.Const.get! t₁ k | null | true |
_private.Mathlib.SetTheory.Lists.0.Lists'.toList.match_1.splitter | Mathlib.SetTheory.Lists | {α : Type u_1} →
(motive : (x : Bool) → Lists' α x → Sort u_2) →
(x : Bool) →
(x_1 : Lists' α x) →
((a : α) → motive false (Lists'.atom a)) →
(Unit → motive true Lists'.nil) →
((b : Bool) → (a : Lists' α b) → (l : Lists' α true) → motive true (a.cons' l)) → motive x x_1 | null | true |
AlgHom.coeOutAddMonoidHom | Mathlib.Algebra.Algebra.Hom | {R : Type u} →
{A : Type v} →
{B : Type w} →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[inst_2 : Semiring B] → [inst_3 : Algebra R A] → [inst_4 : Algebra R B] → CoeOut (A →ₐ[R] B) (A →+ B) | null | true |
_private.Lean.DocString.Add.0.Lean.parseVersoDocString._sparseCasesOn_1 | Lean.DocString.Add | {motive_1 : Lean.Syntax → Sort u} →
(t : Lean.Syntax) →
((info : Lean.SourceInfo) →
(kind : Lean.SyntaxNodeKind) → (args : Array Lean.Syntax) → motive_1 (Lean.Syntax.node info kind args)) →
(Nat.hasNotBit 2 t.ctorIdx → motive_1 t) → motive_1 t | null | false |
Topology.scottHausdorff | Mathlib.Topology.Order.ScottTopology | (α : Type u_3) → Set (Set α) → [Preorder α] → TopologicalSpace α | The Scott-Hausdorff topology.
A set `u` is open in the Scott-Hausdorff topology iff when the least upper bound of a directed set
`d` lies in `u` then there is a tail of `d` which is a subset of `u`.
For mild conditions on `D`, this is equivalent to saying that open sets are `DirSupInaccOn D`,
and closed sets are `Dir... | true |
MeasureTheory.fundamentalInterior.eq_1 | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ (G : Type u_1) {α : Type u_3} [inst : Group G] [inst_1 : MulAction G α] (s : Set α),
MeasureTheory.fundamentalInterior G s = s \ ⋃ g, ⋃ (_ : g ≠ 1), g • s | null | true |
Unitization.quasispectrum_eq_spectrum_inr | Mathlib.Algebra.Algebra.Spectrum.Quasispectrum | ∀ (R : Type u_3) {A : Type u_4} [inst : CommRing R] [inst_1 : NonUnitalRing A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A] (a : A), quasispectrum R a = spectrum R ↑a | null | true |
Std.Time.Modifier.s.inj | Std.Time.Format.Basic | ∀ {presentation presentation_1 : Std.Time.Number},
Std.Time.Modifier.s presentation = Std.Time.Modifier.s presentation_1 → presentation = presentation_1 | null | true |
CategoryTheory.instInhabitedIsSplitCoequalizerId._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.SplitCoequalizer | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C},
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id X) (CategoryTheory.CategoryStruct.id X) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id X) (CategoryTheory.CategoryStruct.id X) | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.getMsbD_intMin.match_1_1 | Init.Data.BitVec.Lemmas | ∀ (motive : ℕ → ℕ → Prop) (w i : ℕ),
(∀ (x : ℕ), motive 0 x) → (∀ (w : ℕ), motive w.succ 0) → (∀ (w i : ℕ), motive w.succ i.succ) → motive w i | null | false |
Lean.Meta.SynthInstance.SubgoalsResult | Lean.Meta.SynthInstance | Type | See `getSubgoals` and `getSubgoalsAux`
We use the parameter `j` to reduce the number of `instantiate*` invocations.
It is the same approach we use at `forallTelescope` and `lambdaTelescope`.
Given `getSubgoalsAux args j subgoals instVal type`,
we have that `type.instantiateRevRange j args.size args` does not have loos... | true |
Lean.instHashableImport.hash | Lean.Setup | Lean.Import → UInt64 | null | true |
SimpleGraph.fintypeSubtypePathLength._proof_3 | Mathlib.Combinatorics.SimpleGraph.Walk.Counting | ∀ {V : Type u_1} (G : SimpleGraph V) [inst : DecidableEq V] [inst_1 : G.LocallyFinite] (u v : V) (n : ℕ)
(x : { p // p.IsPath ∧ p.length = n }), x ∈ SimpleGraph.fintypeSubtypePathLength._aux_1 G u v n | null | false |
MeasureTheory.measure_univ_of_isMulLeftInvariant | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : TopologicalSpace G] [BorelSpace G] [inst_3 : Group G]
[IsTopologicalGroup G] [WeaklyLocallyCompactSpace G] [NoncompactSpace G] (μ : MeasureTheory.Measure G)
[μ.IsOpenPosMeasure] [μ.IsMulLeftInvariant], μ Set.univ = ⊤ | In a noncompact locally compact group, a left-invariant measure which is positive
on open sets has infinite mass. | true |
ContinuousMultilinearMap.seminormedAddCommGroup._proof_1 | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {𝕜 : Type u_1} {ι : Type u_2} {E : ι → Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : Fintype ι]
(x x_1 : ContinuousMultilinearMap ... | null | false |
CircleDeg1Lift.semiconj_of_isUnit_of_translationNumber_eq | Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | ∀ {f₁ f₂ : CircleDeg1Lift},
IsUnit f₁ → IsUnit f₂ → f₁.translationNumber = f₂.translationNumber → ∃ F, Function.Semiconj ⇑F ⇑f₁ ⇑f₂ | If two lifts of circle homeomorphisms have the same translation number, then they are
semiconjugate by a `CircleDeg1Lift`. This version uses assumptions `IsUnit f₁` and `IsUnit f₂`
to assume that `f₁` and `f₂` are homeomorphisms. | true |
Mathlib.Tactic.BicategoryLike.MkEvalComp.ctorIdx | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | {m : Type → Type} → Mathlib.Tactic.BicategoryLike.MkEvalComp m → ℕ | null | false |
instMonoidalClosedSheafOfHasSheafifyOfFunctorOpposite._proof_5 | Mathlib.CategoryTheory.Sites.CartesianClosed | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] (J : CategoryTheory.GrothendieckTopology C)
(A : Type u_3) [inst_1 : CategoryTheory.Category.{u_2, u_3} A] [CategoryTheory.HasSheafify J A]
[inst_3 : CategoryTheory.CartesianMonoidalCategory A]
[inst_4 : CategoryTheory.MonoidalClosed (CategoryTheory.F... | null | false |
Std.Internal.Do.WPMonad.noConfusionType | Std.Internal.Do.WP.Basic | Sort u_1 →
{m : Type u → Type v} →
{Pred : Type w} →
{EPred : Type w'} →
[inst : Monad m] →
[inst_1 : Std.Internal.Do.Assertion Pred] →
[inst_2 : Std.Internal.Do.Assertion EPred] →
Std.Internal.Do.WPMonad m Pred EPred →
{m' : Type u → Type v} →
... | null | false |
_private.Mathlib.NumberTheory.PythagoreanTriples.0.circleEquivGen._simp_4 | Mathlib.NumberTheory.PythagoreanTriples | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | null | false |
Std.DHashMap.Internal.AssocList.Const.toList_alter | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [EquivBEq α] {a : α} {f : Option β → Option β}
{l : Std.DHashMap.Internal.AssocList α fun x => β},
(Std.DHashMap.Internal.AssocList.Const.alter a f l).toList.Perm (Std.Internal.List.Const.alterKey a f l.toList) | null | true |
CategoryTheory.Bicategory.HasAbsLeftKanLift.mk._flat_ctor | Mathlib.CategoryTheory.Bicategory.Kan.HasKan | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {f : b ⟶ a} {g : c ⟶ a}
(hasInitial : CategoryTheory.Limits.HasInitial (CategoryTheory.Bicategory.LeftLift f g)),
(∀ {x : B} (h : x ⟶ c), CategoryTheory.Bicategory.LanLift.CommuteWith f g h) →
CategoryTheory.Bicategory.HasAbsLeftKanLift f g | null | false |
Nat.Partrec.Code.pair.noConfusion | Mathlib.Computability.PartrecCode | {P : Sort u} → {a a_1 a' a'_1 : Nat.Partrec.Code} → a.pair a_1 = a'.pair a'_1 → (a = a' → a_1 = a'_1 → P) → P | null | false |
Std.DHashMap.Raw.instRepr | Std.Data.DHashMap.Raw | {α : Type u} → {β : α → Type v} → [Repr α] → [(a : α) → Repr (β a)] → Repr (Std.DHashMap.Raw α β) | null | true |
Compactum.join_distrib | Mathlib.Topology.Category.Compactum | ∀ (X : Compactum) (uux : Ultrafilter (Ultrafilter X.A)), X.str (X.join uux) = X.str (Ultrafilter.map X.str uux) | null | true |
CategoryTheory.Bicategory.InducedBicategory.bicategory._proof_6 | Mathlib.CategoryTheory.Bicategory.InducedBicategory | ∀ {B : Type u_1} {C : Type u_2} [inst : CategoryTheory.Bicategory C] {F : B → C}
{a b : CategoryTheory.Bicategory.InducedBicategory C F} {f g : a ⟶ b} (η : f ⟶ g),
CategoryTheory.Bicategory.InducedBicategory.mkHom₂
(CategoryTheory.Bicategory.whiskerLeft (CategoryTheory.CategoryStruct.id a).hom η.hom) =
Ca... | null | false |
ContDiffPointwiseHolderAt.mk._flat_ctor | Mathlib.Analysis.Calculus.ContDiffHolder.Pointwise | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] {k : ℕ} {α : ↑unitInterval} {f : E → F} {a : E},
ContDiffAt ℝ (↑k) f a →
((fun x => iteratedFDeriv ℝ k f x - iteratedFDeriv ℝ k f a) =O[nhds a] fun x => ‖x - a‖ ^ ↑... | null | false |
Std.TreeMap.maxKey!_mem | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [inst : Inhabited α],
t.isEmpty = false → t.maxKey! ∈ t | null | true |
ValuativeRel.Rel.rfl | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : ValuativeRel R] {x : R}, x ≤ᵥ x | **Alias** of `ValuativeRel.vle.rfl`.
---
**Alias** of `ValuativeRel.vle_rfl`. | true |
Lean.Core.modifyCache | Lean.CoreM | (Lean.Core.Cache → Lean.Core.Cache) → Lean.CoreM Unit | null | true |
Stream'.Seq.BisimO.eq_1 | Mathlib.Data.Seq.Defs | ∀ {α : Type u} (R : Stream'.Seq α → Stream'.Seq α → Prop), Stream'.Seq.BisimO R none none = True | null | true |
FirstOrder.Language.Ultraproduct.term_realize_cast | Mathlib.ModelTheory.Ultraproducts | ∀ {α : Type u_1} {M : α → Type u_2} {u : Ultrafilter α} {L : FirstOrder.Language} [inst : (a : α) → L.Structure (M a)]
{β : Type u_3} (x : β → (a : α) → M a) (t : L.Term β),
FirstOrder.Language.Term.realize (fun i => Quotient.mk' (x i)) t =
Quotient.mk' fun a => FirstOrder.Language.Term.realize (fun i => x i a)... | null | true |
Num.lt_to_nat | Mathlib.Data.Num.Lemmas | ∀ {m n : Num}, ↑m < ↑n ↔ m < n | null | true |
Turing.PartrecToTM2.trNat_default | Mathlib.Computability.TuringMachine.ToPartrec | Turing.PartrecToTM2.trNat default = [] | null | true |
controlled_closure_of_complete | Mathlib.Analysis.Normed.Group.ControlledClosure | ∀ {G : Type u_1} [inst : NormedAddCommGroup G] [CompleteSpace G] {H : Type u_2} [inst_2 : NormedAddCommGroup H]
{f : NormedAddGroupHom G H} {K : AddSubgroup H} {C ε : ℝ},
0 < C → 0 < ε → f.SurjectiveOnWith K C → f.SurjectiveOnWith K.topologicalClosure (C + ε) | Given `f : NormedAddGroupHom G H` for some complete `G` and a subgroup `K` of `H`, if every
element `x` of `K` has a preimage under `f` whose norm is at most `C*‖x‖` then the same holds for
elements of the (topological) closure of `K` with constant `C+ε` instead of `C`, for any
positive `ε`.
| true |
instSMulDistribClassAlgEquiv | Mathlib.RingTheory.Invariant.Basic | ∀ (A : Type u_1) (K : Type u_2) (L : Type u_3) (B : Type u_4) [inst : CommRing A] [inst_1 : CommRing B]
[inst_2 : Field K] [inst_3 : Field L] [inst_4 : Algebra A K] [inst_5 : Algebra B L] [inst_6 : IsFractionRing A K]
[inst_7 : Algebra A B] [inst_8 : Algebra K L] [inst_9 : Algebra A L] [inst_10 : IsScalarTower A K ... | null | true |
UpperSet.instCommMonoid.eq_1 | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : Preorder α] [inst_2 : IsOrderedMonoid α],
UpperSet.instCommMonoid =
{ toSemigroup := UpperSet.commSemigroup.toSemigroup, toOne := UpperSet.instOne, one_mul := ⋯, mul_one := ⋯,
npow := npowRecAuto, npow_zero := ⋯, npow_succ := ⋯, mul_comm := ⋯ } | null | true |
BoundedContinuousFunction.isBounded_range | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β]
(f : BoundedContinuousFunction α β), Bornology.IsBounded (Set.range ⇑f) | null | true |
Lean.Meta.Simp.NormCastConfig.decide._inherited_default | Init.MetaTypes | Bool | null | false |
Matrix.superFactorial_dvd_vandermonde_det | Mathlib.LinearAlgebra.Vandermonde | ∀ {n : ℕ} (v : Fin (n + 1) → ℤ), ↑n.superFactorial ∣ (Matrix.vandermonde v).det | null | true |
Filter.Germ.instRightCancelSemigroup | Mathlib.Order.Filter.Germ.Basic | {α : Type u_1} → {l : Filter α} → {M : Type u_5} → [RightCancelSemigroup M] → RightCancelSemigroup (l.Germ M) | null | true |
LinearMap.toContinuousBilinearMap_apply | Mathlib.Topology.Algebra.Module.FiniteDimensionBilinear | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] [inst_1 : CompleteSpace 𝕜] {E : Type u_2} [inst_2 : AddCommGroup E]
[inst_3 : Module 𝕜 E] [inst_4 : TopologicalSpace E] [inst_5 : IsTopologicalAddGroup E] [inst_6 : ContinuousSMul 𝕜 E]
[inst_7 : FiniteDimensional 𝕜 E] [inst_8 : T2Space E] {F : Type u_3} [ins... | null | true |
_private.Mathlib.NumberTheory.Fermat.0.Nat.prod_fermatNumber._proof_1_3 | Mathlib.NumberTheory.Fermat | ∀ (n : ℕ), 2 ^ (2 ^ n * 2) - 1 = 1 + 2 ^ (2 ^ n * 2) - 2 | null | false |
IsMinOn.bddBelow | Mathlib.Order.Filter.Extr | ∀ {α : Type u} {β : Type v} [inst : Preorder β] {f : α → β} {s : Set α} {a : α}, IsMinOn f s a → BddBelow (f '' s) | null | true |
Lean.Parser.ParserCategory.mk | Lean.Parser.Basic | Lean.Name →
Lean.Parser.SyntaxNodeKindSet →
Lean.Parser.PrattParsingTables → Lean.Parser.LeadingIdentBehavior → Lean.Parser.ParserCategory | null | true |
List.countP.go._unsafe_rec | Init.Data.List.Basic | {α : Type u} → (α → Bool) → List α → ℕ → ℕ | null | false |
Affine.Simplex.restrict_points_coe | Mathlib.LinearAlgebra.AffineSpace.Simplex.Basic | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_5} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {n : ℕ} (s : Affine.Simplex k P n) (S : AffineSubspace k P)
(hS : affineSpan k (Set.range s.points) ≤ S) (i : Fin (n + 1)), ↑((s.restrict S hS).points i) = s.points i | null | true |
_private.Mathlib.CategoryTheory.Bicategory.Free.0.CategoryTheory.FreeBicategory._aux_Mathlib_CategoryTheory_Bicategory_Free___unexpand_CategoryTheory_FreeBicategory_Hom₂_right_unitor_inv_1 | Mathlib.CategoryTheory.Bicategory.Free | Lean.PrettyPrinter.Unexpander | null | false |
IsRelPrime.mul_add_left_left_iff | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u_1} [inst : CommRing R] {x y z : R}, IsRelPrime (y * z + x) y ↔ IsRelPrime x y | null | true |
_private.Init.Data.String.Slice.0.String.Slice.SplitIterator.toOption.match_1.splitter | Init.Data.String.Slice | {ρ : Type} →
{σ : String.Slice → Type} →
{pat : ρ} →
[inst : String.Slice.Pattern.ToForwardSearcher pat σ] →
{s : String.Slice} →
(motive : String.Slice.SplitIterator pat s → Sort u_1) →
(x : String.Slice.SplitIterator pat s) →
((currPos : s.Pos) →
... | null | true |
Module.Relations.Solution.postcomp_var | Mathlib.Algebra.Module.Presentation.Basic | ∀ {A : Type u} [inst : Ring A] {relations : Module.Relations A} {M : Type v} [inst_1 : AddCommGroup M]
[inst_2 : Module A M] (solution : relations.Solution M) {N : Type v'} [inst_3 : AddCommGroup N] [inst_4 : Module A N]
(f : M →ₗ[A] N) (g : relations.G), (solution.postcomp f).var g = f (solution.var g) | null | true |
CategoryTheory.ShortComplex.SnakeInput.naturality_φ₁ | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{S₁ S₂ : CategoryTheory.ShortComplex.SnakeInput C} (f : S₁ ⟶ S₂),
CategoryTheory.CategoryStruct.comp S₁.φ₁ f.f₂.τ₁ =
CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.SnakeInput.functorP.map f) S₂.φ₁ | null | true |
CategoryTheory.Limits.Types.Small.limitConeIsLimit._proof_3 | Mathlib.CategoryTheory.Limits.Types.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} J] (F : CategoryTheory.Functor J (Type u_1))
[inst_1 : Small.{u_1, max u_1 u_3} ↑F.sections] (x : CategoryTheory.Limits.Cone F)
(x_1 : x.pt ⟶ (CategoryTheory.Limits.Types.Small.limitCone F).pt),
(∀ (j : J),
CategoryTheory.CategoryStruct.comp x_1 ((... | null | false |
PiTensorProduct.lift._proof_7 | Mathlib.LinearAlgebra.PiTensorProduct | ∀ {ι : Type u_1} {R : Type u_2} [inst : CommSemiring R] {s : ι → Type u_3} [inst_1 : (i : ι) → AddCommMonoid (s i)]
[inst_2 : (i : ι) → Module R (s i)] {E : Type u_4} [inst_3 : AddCommMonoid E] [inst_4 : Module R E]
(φ : MultilinearMap R s E) (x y : PiTensorProduct R fun i => s i),
(↑(PiTensorProduct.liftAux φ)).... | null | false |
CategoryTheory.CartesianMonoidalCategory.associator_inv_fst_fst | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(X Y Z : C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator X Y Z).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.SemiCartesianMonoidalCategory.... | null | true |
Prod.continuousConstSMul | Mathlib.Topology.Algebra.ConstMulAction | ∀ {M : Type u_1} {α : Type u_2} {β : Type u_3} [inst : TopologicalSpace α] [inst_1 : SMul M α] [ContinuousConstSMul M α]
[inst_3 : TopologicalSpace β] [inst_4 : SMul M β] [ContinuousConstSMul M β], ContinuousConstSMul M (α × β) | null | true |
Lean.LeanOptionValue.ofString | Lean.Util.LeanOptions | String → Lean.LeanOptionValue | null | true |
_private.Init.Data.Iterators.Lemmas.Combinators.Take.0.Std.Iter.step_take.match_1.eq_1 | Init.Data.Iterators.Lemmas.Combinators.Take | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] {it : Std.Iter β} (motive : it.Step → Sort u_2) (it' : Std.Iter β)
(out : β) (h : it.IsPlausibleStep (Std.IterStep.yield it' out))
(h_1 :
(it' : Std.Iter β) →
(out : β) → (h : it.IsPlausibleStep (Std.IterStep.yield it' out)) → motive ⟨Std.IterStep.yield it' ... | null | true |
instMinISize | Init.Data.SInt.Basic | Min ISize | null | true |
MeasureTheory.stoppedValue_const_smul | Mathlib.Probability.Process.Stopping | ∀ {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : Nonempty ι] {u : ι → Ω → β} {τ : Ω → WithTop ι} {𝕜 : Type u_4}
[inst_1 : SMul 𝕜 β] (c : 𝕜), MeasureTheory.stoppedValue (c • u) τ = c • MeasureTheory.stoppedValue u τ | null | true |
Std.ExtTreeMap.getKeyD_insertManyIfNewUnit_list_of_mem | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α Unit cmp} [inst : Std.TransCmp cmp] {l : List α}
{k fallback : α}, k ∈ t → (t.insertManyIfNewUnit l).getKeyD k fallback = t.getKeyD k fallback | null | true |
CategoryTheory.Comonad.Coalgebra.eilenbergMoore._proof_2 | Mathlib.CategoryTheory.Monad.Algebra | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {G : CategoryTheory.Comonad C} {X Y : G.Coalgebra}
(f : X ⟶ Y), CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id X) f = f | null | false |
ampleSet_empty._simp_1 | Mathlib.Analysis.Convex.AmpleSet | ∀ {F : Type u_1} [inst : AddCommGroup F] [inst_1 : Module ℝ F] [inst_2 : TopologicalSpace F], AmpleSet ∅ = True | null | false |
OrderType.type_ulift | Mathlib.Order.Types.Defs | ∀ {α : Type u} [inst : LinearOrder α], OrderType.type (ULift.{v, u} α) = OrderType.lift.{v, u} (OrderType.type α) | null | true |
_private.Mathlib.Topology.Compactness.CompactlyCoherentSpace.0.CompactCoherentification.isClosed_iff._simp_1_1 | Mathlib.Topology.Compactness.CompactlyCoherentSpace | ∀ {α : Type u_1} {β : Type u_2} {t : TopologicalSpace α} {s : Set β} {f : α → β}, IsClosed s = IsClosed (f ⁻¹' s) | null | false |
MeasureTheory.measureReal_mono | Mathlib.MeasureTheory.Measure.Real | ∀ {α : Type u_1} {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s₁ s₂ : Set α},
s₁ ⊆ s₂ → autoParam (μ s₂ ≠ ⊤) MeasureTheory.measureReal_mono._auto_1 → μ.real s₁ ≤ μ.real s₂ | null | true |
upperBounds_Ioo | Mathlib.Order.Bounds.Basic | ∀ {γ : Type u_3} [inst : SemilatticeInf γ] [DenselyOrdered γ] {a b : γ}, a < b → upperBounds (Set.Ioo a b) = Set.Ici b | null | true |
SchauderBasis.RankOneDecomposition.mk.noConfusion | Mathlib.Analysis.Normed.Module.Bases | {𝕜 : Type u_1} →
{inst : NontriviallyNormedField 𝕜} →
{X : Type u_2} →
{inst_1 : NormedAddCommGroup X} →
{inst_2 : NormedSpace 𝕜 X} →
{P : Sort u} →
{P_1 : ℕ → X →L[𝕜] X} →
{e : ℕ → X} →
{proj_zero : P_1 0 = 0} →
{finrank_rang... | null | false |
CategoryTheory.Pretriangulated.shiftFunctorCompIsoId_op_inv_app._auto_1 | Mathlib.CategoryTheory.Triangulated.Opposite.Basic | Lean.Syntax | null | false |
_private.Mathlib.Analysis.Analytic.IsolatedZeros.0.HasSum.exists_hasSum_smul_of_apply_eq_zero._simp_1_7 | Mathlib.Analysis.Analytic.IsolatedZeros | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False | null | false |
Lean.Meta.ApplyNewGoals.toCtorIdx | Init.Meta.Defs | Lean.Meta.ApplyNewGoals → ℕ | null | false |
Std.HashMap.Raw.contains_insert_self | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], m.WF → ∀ {k : α} {v : β}, (m.insert k v).contains k = true | null | true |
contDiffAt_infty | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{x : E}, ContDiffAt 𝕜 (↑⊤) f x ↔ ∀ (n : ℕ), ContDiffAt 𝕜 (↑n) f x | null | true |
Int.abs_eq_normalize | Mathlib.Algebra.GCDMonoid.Nat | ∀ (z : ℤ), |z| = normalize z | null | true |
Set.mk_preimage_sym2 | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {s : Set α}, Function.uncurry Sym2.mk ⁻¹' s.sym2 = s ×ˢ s | null | true |
Set.mapsTo_image_iff._simp_1 | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β} {g : γ → α} {s : Set γ} {t : Set β},
Set.MapsTo f (g '' s) t = Set.MapsTo (f ∘ g) s t | null | false |
exists_eq'._simp_1 | Init.PropLemmas | ∀ {α : Sort u_1} {a' : α}, (∃ a, a' = a) = True | null | false |
List.iSup_mem_map_of_exists_sSup_empty_le | Mathlib.Order.ConditionallyCompleteLattice.Finset | ∀ {ι : Type u_1} {α : Type u_2} [inst : ConditionallyCompleteLinearOrder α] {l : List ι} (f : ι → α),
(∃ x ∈ l, sSup ∅ ≤ f x) → ⨆ x ∈ l, f x ∈ List.map f l | null | true |
UpperHalfPlane.metricSpaceAux._proof_3 | Mathlib.Analysis.Complex.UpperHalfPlane.Metric | uniformity UpperHalfPlane = ⨅ ε, ⨅ (_ : ε > 0), Filter.principal {p | dist p.1 p.2 < ε} | null | false |
DecidableLT._to_dual_cast_4 | Mathlib.Tactic.ToDual | (α : Type u) → [inst : LT α] → (DecidableRel fun a a_1 => a_1 < a) → DecidableLT α | null | false |
WeierstrassCurve.ctorIdx | Mathlib.AlgebraicGeometry.EllipticCurve.Weierstrass | {R : Type u} → WeierstrassCurve R → ℕ | null | false |
AddMonoid.Coprod.clift_apply_inl | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} {P : Type u_5} [inst : AddZeroClass M] [inst_1 : AddZeroClass N]
[inst_2 : AddZeroClass P] (f : FreeAddMonoid (M ⊕ N) →+ P) (hM₁ : f (FreeAddMonoid.of (Sum.inl 0)) = 0)
(hN₁ : f (FreeAddMonoid.of (Sum.inr 0)) = 0)
(hM :
∀ (x y : M),
f (FreeAddMonoid.of (Sum.inl (x + y))) ... | null | true |
Subtype.restrict_injective | Mathlib.Data.Subtype | ∀ {α : Sort u_4} {β : Type u_5} {f : α → β} (p : α → Prop),
Function.Injective f → Function.Injective (Subtype.restrict p f) | null | true |
Subsemigroup.unop_le_unop_iff | Mathlib.Algebra.Group.Subsemigroup.MulOpposite | ∀ {M : Type u_2} [inst : Mul M] {S₁ S₂ : Subsemigroup Mᵐᵒᵖ}, S₁.unop ≤ S₂.unop ↔ S₁ ≤ S₂ | null | true |
UpperSet.instCompleteLinearOrder._proof_3 | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LinearOrder α] (a b c : UpperSet α), a ≤ b → a ≤ c → a ≤ Lattice.inf b c | null | false |
PMF.toMeasure_bindOnSupport_apply | Mathlib.Probability.ProbabilityMassFunction.Monad | ∀ {α : Type u_1} {β : Type u_2} {p : PMF α} (f : (a : α) → a ∈ p.support → PMF β) (s : Set β)
[inst : MeasurableSpace β],
MeasurableSet s → (p.bindOnSupport f).toMeasure s = ∑' (a : α), p a * if h : p a = 0 then 0 else (f a h).toMeasure s | The measure of a set under `p.bindOnSupport f` is the sum over `a : α`
of the probability of `a` under `p` times the measure of the set under `f a _`.
The additional if statement is needed since `f` is only a partial function. | true |
Std.DHashMap.Internal.Raw₀.getThenInsertIfNew?_fst | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α]
[inst_2 : LawfulBEq α] {k : α} {v : β k}, (m.getThenInsertIfNew? k v).1 = m.get? k | null | true |
Lean.Elab.CommandContextInfo.mk._flat_ctor | Lean.Elab.InfoTree.Types | Lean.Environment →
Option Lean.Environment →
Lean.FileMap →
Lean.MetavarContext →
Lean.Options → Lean.Name → List Lean.OpenDecl → Lean.NameGenerator → Lean.Elab.CommandContextInfo | null | false |
Std.DHashMap.Equiv.isEmpty_eq | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.DHashMap α β} [EquivBEq α]
[LawfulHashable α], m₁.Equiv m₂ → m₁.isEmpty = m₂.isEmpty | null | true |
_private.Mathlib.Algebra.Homology.SpectralObject.SpectralSequence.0.CategoryTheory.Abelian.SpectralObject.SpectralSequence.HomologyData.isIso_mapFourδ₁Toδ₀'._proof_1_1 | Mathlib.Algebra.Homology.SpectralObject.SpectralSequence | ∀ {ι : Type u_1} {κ : Type u_2} [inst : Preorder ι] {c : ℤ → ComplexShape κ} {r₀ : ℤ}
(data : CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore ι c r₀) (pq' : κ) (n₁ n₂ : ℤ),
n₁ = data.deg pq' → n₁ + 1 = n₂ → n₂ = data.deg pq' + 1 | null | false |
_private.Mathlib.GroupTheory.Perm.Support.0.Equiv.Perm.IsSwap.of_subtype_isSwap.match_1_1 | Mathlib.GroupTheory.Perm.Support | ∀ {α : Type u_1} [inst : DecidableEq α] {p : α → Prop} {f : Equiv.Perm (Subtype p)} (motive : f.IsSwap → Prop)
(h : f.IsSwap),
(∀ (x : α) (hx : p x) (y : α) (hy : p y) (hxy : ⟨x, hx⟩ ≠ ⟨y, hy⟩ ∧ f = Equiv.swap ⟨x, hx⟩ ⟨y, hy⟩), motive ⋯) →
motive h | null | false |
_private.Mathlib.Analysis.Calculus.LHopital.0.HasDerivAt.lhopital_zero_nhdsNE._simp_1_2 | Mathlib.Analysis.Calculus.LHopital | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {x₁ x₂ : Filter α} {y : Filter β},
Filter.Tendsto f (x₁ ⊔ x₂) y = (Filter.Tendsto f x₁ y ∧ Filter.Tendsto f x₂ y) | null | false |
ContinuousMap.Homotopy.pi._proof_1 | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u_1} {ι : Type u_3} [inst : TopologicalSpace X] {Y : ι → Type u_2}
[inst_1 : (i : ι) → TopologicalSpace (Y i)] {f₀ f₁ : (i : ι) → C(X, Y i)} (i : ι),
ContinuousMapClass ((f₀ i).Homotopy (f₁ i)) (↑unitInterval × X) (Y i) | null | false |
Polynomial.IsUnitTrinomial.irreducible_aux2 | Mathlib.Algebra.Polynomial.UnitTrinomial | ∀ {p q : Polynomial ℤ} {k m m' n : ℕ},
k < m →
m < n →
k < m' →
m' < n →
∀ (u v w : ℤˣ),
p = Polynomial.trinomial k m n ↑u ↑v ↑w →
q = Polynomial.trinomial k m' n ↑u ↑v ↑w → p * p.mirror = q * q.mirror → q = p ∨ q = p.mirror | null | true |
Filter.sup_prod | Mathlib.Order.Filter.Prod | ∀ {α : Type u_1} {β : Type u_2} (f₁ f₂ : Filter α) (g : Filter β), (f₁ ⊔ f₂) ×ˢ g = f₁ ×ˢ g ⊔ f₂ ×ˢ g | null | true |
_private.Mathlib.NumberTheory.FrobeniusNumber.0.Nat.exists_mem_span_nat_finset_of_ge.match_1_3 | Mathlib.NumberTheory.FrobeniusNumber | ∀ (s : Set ℕ) (motive : (∃ n ∈ s, n ≠ 0) → Prop) (x : ∃ n ∈ s, n ≠ 0),
(∀ (x : ℕ) (hxs : x ∈ s) (hx : x ≠ 0), motive ⋯) → motive x | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.