name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Std.DTreeMap.Internal.Impl.applyPartition_eq_apply_toListModel | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} {δ : Type w} [inst : Ord α] [inst_1 : Std.TransOrd α] [inst_2 : BEq α]
[inst_3 : Std.LawfulBEqOrd α] {k : α} {l : Std.DTreeMap.Internal.Impl α β},
l.Ordered →
∀
{f :
List ((a : α) × β a) →
(c : Std.DTreeMap.Internal.Cell α β (compare k)) →
(Std... | null | true |
Lean.Elab.Do.InferControlInfo.ofSeq | Lean.Elab.Do.InferControlInfo | Lean.TSyntax `Lean.Parser.Term.doSeq → Lean.Elab.TermElabM Lean.Elab.Do.ControlInfo | null | true |
CategoryTheory.Equivalence.mapCommMon_inverse | Mathlib.CategoryTheory.Monoidal.CommMon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {D : Type u₂} [inst_3 : CategoryTheory.Category.{v₂, u₂} D]
[inst_4 : CategoryTheory.MonoidalCategory D] [inst_5 : CategoryTheory.BraidedCategory D] (e : C ≌ D)
[ins... | null | true |
Homeomorph.comp_isOpenMap_iff._simp_1 | Mathlib.Topology.Homeomorph.Defs | ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_4} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] (h : X ≃ₜ Y) {f : Z → X}, IsOpenMap (⇑h ∘ f) = IsOpenMap f | null | false |
Mathlib.Tactic.Order.OrderType.lin.sizeOf_spec | Mathlib.Tactic.Order.Preprocessing | sizeOf Mathlib.Tactic.Order.OrderType.lin = 1 | null | true |
CategoryTheory.Limits.walkingCospanOpEquiv_inverse_obj | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | ∀ (X : CategoryTheory.Limits.WidePushoutShape CategoryTheory.Limits.WalkingPair),
CategoryTheory.Limits.walkingCospanOpEquiv.inverse.obj X = Opposite.op X | null | true |
_private.Init.Data.Nat.Control.0.Nat.forM.loop._unsafe_rec | Init.Data.Nat.Control | {m : Type → Type u_1} → [Monad m] → (n : ℕ) → ((i : ℕ) → i < n → m Unit) → (i : ℕ) → i ≤ n → m Unit | null | false |
SymAlg.instCommMagmaOfInvertibleOfNat | Mathlib.Algebra.Symmetrized | {α : Type u_1} → [inst : Ring α] → [Invertible 2] → CommMagma αˢʸᵐ | null | true |
LeanSearchClient.instReprSearchResult | LeanSearchClient.Syntax | Repr LeanSearchClient.SearchResult | null | true |
CategoryTheory.IsSplitMono.casesOn | Mathlib.CategoryTheory.EpiMono | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X Y : C} →
{f : X ⟶ Y} →
{motive : CategoryTheory.IsSplitMono f → Sort u} →
(t : CategoryTheory.IsSplitMono f) →
((exists_splitMono : Nonempty (CategoryTheory.SplitMono f)) → motive ⋯) → motive t | null | false |
Nat.mul_left_comm | Init.Data.Nat.Basic | ∀ (n m k : ℕ), n * (m * k) = m * (n * k) | null | true |
MultilinearMap.domDomCongr_eq_iff._simp_1 | Mathlib.LinearAlgebra.Multilinear.Basic | ∀ {R : Type uR} {M₂ : Type v₂} {M₃ : Type v₃} [inst : Semiring R] [inst_1 : AddCommMonoid M₂]
[inst_2 : AddCommMonoid M₃] [inst_3 : Module R M₂] [inst_4 : Module R M₃] {ι₁ : Type u_1} {ι₂ : Type u_2}
(σ : ι₁ ≃ ι₂) (f g : MultilinearMap R (fun x => M₂) M₃),
(MultilinearMap.domDomCongr σ f = MultilinearMap.domDomCo... | null | false |
UInt16.toFin_mod | Init.Data.UInt.Lemmas | ∀ (a b : UInt16), (a % b).toFin = a.toFin % b.toFin | null | true |
PadicSeq.valuation | Mathlib.NumberTheory.Padics.PadicNumbers | {p : ℕ} → [Fact (Nat.Prime p)] → PadicSeq p → ℤ | The `p`-adic valuation on `ℚ` lifts to `PadicSeq p`.
`Valuation f` is defined to be the valuation of the (`ℚ`-valued) stationary point of `f`. | true |
SimpleGraph.sum_incMatrix_apply_of_notMem_edgeSet | Mathlib.Combinatorics.SimpleGraph.IncMatrix | ∀ {R : Type u_1} {α : Type u_2} (G : SimpleGraph α) [inst : NonAssocSemiring R] [inst_1 : DecidableEq α]
[inst_2 : DecidableRel G.Adj] {e : Sym2 α} [inst_3 : Fintype α],
e ∉ G.edgeSet → ∑ a, SimpleGraph.incMatrix R G a e = 0 | null | true |
MeasureTheory.Measure.toOuterMeasure_top | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} {x : MeasurableSpace α}, ⊤.toOuterMeasure = ⊤ | null | true |
_private.Mathlib.Analysis.ConstantSpeed.0.unique_unit_speed_on_Icc_zero._simp_1_1 | Mathlib.Analysis.ConstantSpeed | ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, (x ∈ Set.Icc a b) = (a ≤ x ∧ x ≤ b) | null | false |
ValueDistribution.logCounting_const | Mathlib.Analysis.Complex.ValueDistribution.LogCounting.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] [inst_1 : ProperSpace 𝕜] {E : Type u_2}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {c : E} {e : WithTop E},
ValueDistribution.logCounting (fun x => c) e = 0 | The logarithmic counting function of a constant function is zero.
| true |
PairReduction.finset_logSizeBallSeq_subset_logSizeBallSeq_init | Mathlib.Topology.EMetricSpace.PairReduction | ∀ {T : Type u_1} [inst : PseudoEMetricSpace T] {a c : ENNReal} {J : Finset T} [inst_1 : DecidableEq T] (hJ : J.Nonempty)
(i : ℕ), (PairReduction.logSizeBallSeq J hJ a c i).finset ⊆ J | null | true |
instIsLocalizationAlgebraMapSubmonoidPrimeComplLocalization | Mathlib.RingTheory.DedekindDomain.Instances | ∀ {R : Type u_1} (S : Type u_2) (T : Type u_3) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T]
[inst_3 : Algebra R S] {P : Ideal R} [inst_4 : P.IsPrime] [inst_5 : Algebra S T] [inst_6 : Algebra R T]
[IsScalarTower R S T],
IsLocalization (Algebra.algebraMapSubmonoid T (Algebra.algebraMapSubmonoid S... | null | true |
List.zipWithM'._sunfold | Init.Data.List.Monadic | {m : Type u → Type v} →
[Monad m] → {α : Type w} → {β : Type x} → {γ : Type u} → (α → β → m γ) → List α → List β → m (List γ) | null | false |
RootPairing.coroot_eq_neg_iff | Mathlib.LinearAlgebra.RootSystem.Defs | ∀ {ι : 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) {i j : ι},
P.coroot i = -P.coroot j ↔ i = (P.reflectionPerm j) j | null | true |
_private.Lean.Meta.Eqns.0.Lean.Meta.mkSimpleEqThm.match_1 | Lean.Meta.Eqns | (motive : Option Lean.ConstantInfo → Sort u_1) →
(x : Option Lean.ConstantInfo) →
((info : Lean.DefinitionVal) → motive (some (Lean.ConstantInfo.defnInfo info))) →
((x : Option Lean.ConstantInfo) → motive x) → motive x | null | false |
UInt8.ext | Batteries.Data.UInt | ∀ {x y : UInt8}, x.toNat = y.toNat → x = y | null | true |
Function.smulCommClass | Mathlib.Algebra.Group.Action.Pi | ∀ {ι : Type u_1} {M : Type u_2} {N : Type u_3} {α : Type u_7} [inst : SMul M α] [inst_1 : SMul N α]
[SMulCommClass M N α], SMulCommClass M N (ι → α) | Non-dependent version of `Pi.smulCommClass`. Lean gets confused by the dependent instance if
this is not present. | true |
CategoryTheory.LiftableCone.validLift | Mathlib.CategoryTheory.Limits.Creates | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{J : Type w} →
[inst_2 : CategoryTheory.Category.{w', w} J] →
{K : CategoryTheory.Functor J C} →
{F : CategoryTheory.Functor C D} →
... | the isomorphism expressing that `liftedCone` lifts the given cone | true |
FiniteGaloisIntermediateField.finGaloisGroup._proof_2 | Mathlib.FieldTheory.Galois.Profinite | ∀ {k : Type u_2} {K : Type u_1} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K]
(L : FiniteGaloisIntermediateField k K), Finite Gal(↥L.toIntermediateField/k) | null | false |
Std.Roo.size_eq_match_roc | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Roo α} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.Rxo.HasSize α] [Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLT α]
[Std.Rxo.IsAlwaysFinite α] [Std.Rxo.LawfulHasSize α],
r.size =
match Std.PRange.succ? r.lowe... | null | true |
Mathlib.Tactic.LibrarySearch.observe | Mathlib.Tactic.Observe | Lean.ParserDescr | `observe hp : p` asserts the proposition `p` as a hypothesis named `hp`, and tries to prove it
using `exact?`.
If no proof is found, the tactic fails.
In other words, this tactic is equivalent to `have hp : p := by exact?`.
* `observe : p` uses the name `this` for the new hypothesis.
* `observe? hp : p` will emit a tr... | true |
List.flatten._sunfold | Init.Prelude | {α : Type u_1} → List (List α) → List α | null | false |
_private.Mathlib.Data.Nat.Dist.0.Nat.dist_zero_right._proof_1_1 | Mathlib.Data.Nat.Dist | ∀ (n : ℕ), n - 0 + (0 - n) = n | null | false |
NNRat.divNat_zero | Mathlib.Data.NNRat.Defs | ∀ (n : ℕ), NNRat.divNat n 0 = 0 | null | true |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.activateNextGuard.go.match_1 | Lean.Meta.Tactic.Grind.Types | (motive : Lean.Meta.Simp.Result → Sort u_1) →
(x : Lean.Meta.Simp.Result) →
((e : Lean.Expr) →
(proof? : Option Lean.Expr) → (cache : Bool) → motive { expr := e, proof? := proof?, cache := cache }) →
motive x | null | false |
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.D₃.congr_simp | Mathlib.CategoryTheory.Presentable.Directed | ∀ {J : Type w} [inst : CategoryTheory.SmallCategory J] {κ : Cardinal.{w}} [inst_1 : Fact κ.IsRegular]
(D D_1 : CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.DiagramWithUniqueTerminal J κ),
D = D_1 →
∀ (m₁ m₁_1 : J),
m₁ = m₁_1 →
CategoryTheory.IsCardinalFiltered.exists_cardinal_directe... | null | true |
Lean.Grind.CommRing.Poly.noConfusion | Init.Grind.Ring.CommSolver | {P : Sort u} → {t t' : Lean.Grind.CommRing.Poly} → t = t' → Lean.Grind.CommRing.Poly.noConfusionType P t t' | null | false |
continuousAt_codRestrict_iff | Mathlib.Topology.Constructions | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {t : Set Y}
(h1 : ∀ (x : X), f x ∈ t) {x : X}, ContinuousAt (Set.codRestrict f t h1) x ↔ ContinuousAt f x | null | true |
RingHom.CodescendsAlong.algebraMap_tensorProduct | Mathlib.RingTheory.RingHomProperties | ∀ {P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop}
(Q : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop) (R S T : Type u)
[inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] [inst_3 : CommRing T] [inst_4 : Algebra R T],
(RingHom.Cod... | null | true |
_private.Mathlib.Data.Set.Insert.0.HasSubset.Subset.ssubset_of_mem_notMem._proof_1_1 | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {s t : Set α} {a : α}, s ⊆ t → a ∈ t → a ∉ s → s ⊂ t | null | false |
SetRel.IsSeparated.empty | Mathlib.Data.Rel.Separated | ∀ {X : Type u_1} {R : SetRel X X}, R.IsSeparated ∅ | null | true |
star_pow | Mathlib.Algebra.Star.Basic | ∀ {R : Type u} [inst : Monoid R] [inst_1 : StarMul R] (x : R) (n : ℕ), star (x ^ n) = star x ^ n | null | true |
Matrix.isRepresentation.toEnd._proof_8 | Mathlib.LinearAlgebra.Matrix.Charpoly.LinearMap | ∀ {ι : Type u_1} [inst : Fintype ι] (R : Type u_2) [inst_1 : CommRing R] [inst_2 : DecidableEq ι],
ZeroMemClass (Subalgebra R (Matrix ι ι R)) (Matrix ι ι R) | null | false |
Std.Sat.CNF.eval_empty | Std.Sat.CNF.Basic | ∀ {α : Type u_1} (a : α → Bool), Std.Sat.CNF.eval a Std.Sat.CNF.empty = true | null | true |
DiscreteMeasurableSpace.mk | Mathlib.MeasureTheory.MeasurableSpace.Defs | ∀ {α : Type u_7} [inst : MeasurableSpace α], (∀ (s : Set α), MeasurableSet s) → DiscreteMeasurableSpace α | null | true |
Finset.Ioc_subset_Ioc_left | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} {a₁ a₂ b : α} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α],
a₁ ≤ a₂ → Finset.Ioc a₂ b ⊆ Finset.Ioc a₁ b | null | true |
CategoryTheory.CoreSmallCategoryOfSet.homEquiv | Mathlib.CategoryTheory.SmallRepresentatives | {Ω : Type w} →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(self : CategoryTheory.CoreSmallCategoryOfSet Ω C) →
{X Y : ↑self.obj} → ↑(self.hom X Y) ≃ (self.objEquiv X ⟶ self.objEquiv Y) | a bijection between the types of morphisms | true |
LocallyConstant.instCommGroup._proof_6 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : CommGroup Y] (x : LocallyConstant X Y) (x_1 : ℤ),
⇑(x ^ x_1) = ⇑(x ^ x_1) | null | false |
_private.Lean.Meta.Tactic.Subst.0.Lean.Meta.substVar.match_4 | Lean.Meta.Tactic.Subst | (motive : Option (Lean.FVarId × Bool) → Sort u_1) →
(__x : Option (Lean.FVarId × Bool)) →
((fvarId : Lean.FVarId) → (symm : Bool) → motive (some (fvarId, symm))) →
((x : Option (Lean.FVarId × Bool)) → motive x) → motive __x | null | false |
DistribMulActionHom.mk.congr_simp | Mathlib.Algebra.Algebra.Unitization | ∀ {M : Type u_1} [inst : Monoid M] {N : Type u_2} [inst_1 : Monoid N] {φ : M →* N} {A : Type u_10}
[inst_2 : AddMonoid A] [inst_3 : DistribMulAction M A] {B : Type u_11} [inst_4 : AddMonoid B]
[inst_5 : DistribMulAction N B] (toMulActionHom toMulActionHom_1 : A →ₑ[⇑φ] B)
(e_toMulActionHom : toMulActionHom = toMul... | null | true |
SubAddAction.closure | Mathlib.GroupTheory.GroupAction.SubMulAction.Closure | (R : Type u_1) → {M : Type u_2} → [inst : VAdd R M] → Set M → SubAddAction R M | The `SubAddAction` generated by a set `s`. | true |
Set.OrdConnected.isSuccArchimedean | Mathlib.Order.SuccPred.Archimedean | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : SuccOrder α] [IsSuccArchimedean α] (s : Set α)
[inst_3 : s.OrdConnected], IsSuccArchimedean ↑s | null | true |
Lean.Parser.Term.falseVal.formatter | Lean.Parser.Term | Lean.PrettyPrinter.Formatter | null | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.nodup_derivedLits._proof_1_8 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult | ∀ {n : ℕ} (derivedLits_arr : Array (Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)))
(j : Fin derivedLits_arr.size), ↑j + 1 ≤ derivedLits_arr.size → ↑j < derivedLits_arr.size | null | false |
String.Slice.takeWhile_char_eq_takeWhile_beq | Init.Data.String.Lemmas.Pattern.Char | ∀ {c : Char} {s : String.Slice}, s.takeWhile c = s.takeWhile fun x => x == c | null | true |
CategoryTheory.Functor.IsStronglyCartesian.domainIsoOfBaseIso._proof_5 | Mathlib.CategoryTheory.FiberedCategory.Cartesian | ∀ {𝒮 : Type u_4} {𝒳 : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} 𝒮]
[inst_1 : CategoryTheory.Category.{u_1, u_2} 𝒳] (p : CategoryTheory.Functor 𝒳 𝒮) {R R' S : 𝒮} {a a' b : 𝒳} {f : R ⟶ S}
{f' : R' ⟶ S} {g : R' ≅ R} (h : f' = CategoryTheory.CategoryStruct.comp g.hom f) (φ : a ⟶ b) (φ' : a' ⟶ b)
[i... | null | false |
_private.Mathlib.Order.Sublattice.0.Sublattice.map_symm_eq_iff_eq_map._simp_1_3 | Mathlib.Order.Sublattice | ∀ {α : Type u_2} [inst : Lattice α] {L M : Sublattice α}, (L = M) = (↑L = ↑M) | null | false |
Set.image_affine_Ico | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {K : Type u_2} [inst : DivisionSemiring K] [inst_1 : PartialOrder K] [PosMulReflectLT K] [IsOrderedCancelAddMonoid K]
[ExistsAddOfLE K] {a : K},
0 < a → ∀ (b c d : K), (fun x => a * x + b) '' Set.Ico c d = Set.Ico (a * c + b) (a * d + b) | null | true |
_private.Init.Data.String.Decode.0.Char.toNat_le | Init.Data.String.Decode | ∀ {c : Char}, c.toNat ≤ 1114111 | null | true |
CategoryTheory.MorphismProperty.DescendsAlong.recOn | Mathlib.CategoryTheory.MorphismProperty.Descent | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{P Q : CategoryTheory.MorphismProperty C} →
{motive : P.DescendsAlong Q → Sort u} →
(t : P.DescendsAlong Q) →
((of_isPullback :
∀ {A X Y Z : C} {fst : A ⟶ X} {snd : A ⟶ Y} {f : X ⟶ Z} {g : Y ⟶ Z},
... | null | false |
AlgebraicGeometry.Scheme.Modules.pullback._proof_1 | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y),
(SheafOfModules.pushforward (AlgebraicGeometry.Scheme.Hom.toRingCatSheafHom f)).IsRightAdjoint | null | false |
Std.HashMap.contains_modify | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{k k' : α} {f : β → β}, (m.modify k f).contains k' = m.contains k' | null | true |
Algebra.IsIntegral.comap_surjective | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ (R : Type u_1) (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[Algebra.IsIntegral R S] [FaithfulSMul R S], Function.Surjective (PrimeSpectrum.comap (algebraMap R S)) | null | true |
CategoryTheory.Functor.whiskerRight_comp | Mathlib.CategoryTheory.Whiskering | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] {G H K : CategoryTheory.Functor C D} (α : G ⟶ H)
(β : H ⟶ K) (F : CategoryTheory.Functor D E),
CategoryTheory.Functor.whiskerRight (Ca... | null | true |
CategoryTheory.MonoidalCategory.instMonoidalFunctorTensoringRight._proof_6 | Mathlib.CategoryTheory.Monoidal.End | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y Z : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight
(CategoryTheory.Functor.isoWhiskerRight (CategoryTheory.MonoidalCategory.curriedAssociatorNatIso... | null | false |
Lean.PrettyPrinter.Formatter.State.noConfusionType | Lean.PrettyPrinter.Formatter | Sort u → Lean.PrettyPrinter.Formatter.State → Lean.PrettyPrinter.Formatter.State → Sort u | null | false |
Lean.Meta.MatcherApp.remaining | Lean.Meta.Match.MatcherApp.Basic | Lean.Meta.MatcherApp → Array Lean.Expr | null | true |
inv_eq_one_divp | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : Monoid α] (u : αˣ), ↑u⁻¹ = 1 /ₚ u | null | true |
_private.Mathlib.NumberTheory.SmoothNumbers.0.Nat.mem_factoredNumbers_iff_forall_le.match_1_3 | Mathlib.NumberTheory.SmoothNumbers | ∀ {s : Finset ℕ} {m : ℕ} (motive : (m ≠ 0 ∧ ∀ (p : ℕ), Nat.Prime p ∧ p ∣ m ∧ m ≠ 0 → p ∈ s) → Prop)
(x : m ≠ 0 ∧ ∀ (p : ℕ), Nat.Prime p ∧ p ∣ m ∧ m ≠ 0 → p ∈ s),
(∀ (H₀ : m ≠ 0) (H₁ : ∀ (p : ℕ), Nat.Prime p ∧ p ∣ m ∧ m ≠ 0 → p ∈ s), motive ⋯) → motive x | null | false |
PNat.XgcdType.y | Mathlib.Data.PNat.Xgcd | PNat.XgcdType → ℕ | `y` satisfies `b / d = z + y` at the final step. | true |
CategoryTheory.Grp.instMonObj._proof_3 | Mathlib.CategoryTheory.Monoidal.Cartesian.Grp | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {H : CategoryTheory.Grp C} [inst_3 : CategoryTheory.IsCommMonObj H.X],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whis... | null | false |
ContinuousLinearMap.coe_projKerOfRightInverse_apply | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Restrict | ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Ring R₁] [inst_1 : Ring R₂] {σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁}
[inst_2 : RingHomInvPair σ₁₂ σ₂₁] {M₁ : Type u_4} {M₂ : Type u_5} [inst_3 : TopologicalSpace M₁]
[inst_4 : AddCommGroup M₁] [inst_5 : Module R₁ M₁] [inst_6 : TopologicalSpace M₂] [inst_7 : AddCommGroup M₂]
[i... | null | true |
PseudoMetricSpace.toUniformSpace | Mathlib.Topology.MetricSpace.Pseudo.Defs | {α : Type u} → [self : PseudoMetricSpace α] → UniformSpace α | null | true |
Subgroup.instSMul | Mathlib.Algebra.Group.Subgroup.MulOppositeLemmas | {G : Type u_2} → [inst : Group G] → (H : Subgroup G) → SMul (↥H.op) G | We redeclare this instance to get keys
`SMul (@Subtype (MulOpposite _) (@Membership.mem (MulOpposite _)
(Subgroup (MulOpposite _) _) _ (@Subgroup.op _ _ _))) _`
compared to the keys for `Submonoid.smul`
`SMul (@Subtype _ (@Membership.mem _ (Submonoid _ _) _ _)) _` | true |
LaurentPolynomial.C_apply | Mathlib.Algebra.Polynomial.Laurent | ∀ {R : Type u_1} [inst : Semiring R] (t : R) (n : ℤ), (LaurentPolynomial.C t) n = if n = 0 then t else 0 | null | true |
CategoryTheory.MorphismProperty.llp_rlp_of_hasSmallObjectArgument' | Mathlib.CategoryTheory.SmallObject.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (I : CategoryTheory.MorphismProperty C)
[inst_1 : I.HasSmallObjectArgument],
I.rlp.llp =
((CategoryTheory.MorphismProperty.coproducts.{w, v, u} I).pushouts.transfiniteCompositionsOfShape
I.smallObjectκ.ord.ToType).retracts | If `I : MorphismProperty C` permits the small object argument,
then the class of morphisms that have the left lifting property with respect to
the maps that have the right lifting property with respect to `I` are
exactly the retracts of transfinite compositions (indexed by `I.smallObjectκ.ord.ToType`)
of pushouts of co... | true |
Submonoid.LocalizationMap.mulEquivOfLocalizations_right_inv | Mathlib.GroupTheory.MonoidLocalization.Maps | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N] {P : Type u_3}
[inst_2 : CommMonoid P] (f : S.LocalizationMap N) (k : S.LocalizationMap P),
f.ofMulEquivOfLocalizations (f.mulEquivOfLocalizations k) = k | null | true |
CategoryTheory.Functor.hom_ext_of_isLeftKanExtension | Mathlib.CategoryTheory.Functor.KanExtension.Basic | ∀ {C : Type u_1} {H : Type u_3} {D : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_3, u_3} H] [inst_2 : CategoryTheory.Category.{v_4, u_4} D]
(F' : CategoryTheory.Functor D H) {L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor C H}
(α : F ⟶ L.comp F') [F'.I... | null | true |
Besicovitch.TauPackage.color.eq_1 | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u_1} [inst : MetricSpace α] {β : Type u} [inst_1 : Nonempty β] (p : Besicovitch.TauPackage β α)
(x : Ordinal.{u}),
p.color x =
sInf
(Set.univ \
⋃ j,
⋃ (_ :
(Metric.closedBall (p.c (p.index ↑j)) (p.r (p.index ↑j)) ∩
Metric.closedBall (p.c (p.index x... | null | true |
Bundle.Trivialization.preimageSingletonHomeomorph_symm_apply | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_1} {F : Type u_2} {Z : Type u_4} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] {proj : Z → B}
[inst_2 : TopologicalSpace Z] (e : Bundle.Trivialization F proj) {b : B} (hb : b ∈ e.baseSet) (p : F),
(e.preimageSingletonHomeomorph hb).symm p = ⟨↑e.symm (b, p), ⋯⟩ | null | true |
PiTensorProduct.dualDistribEquivOfBasis_symm_apply | Mathlib.LinearAlgebra.PiTensorProduct.Dual | ∀ {ι : Type u_1} {R : Type u_2} {κ : ι → Type u_3} {M : ι → Type u_4} [inst : CommRing R]
[inst_1 : (i : ι) → AddCommGroup (M i)] [inst_2 : (i : ι) → Module R (M i)] [inst_3 : Finite ι]
[inst_4 : ∀ (i : ι), Finite (κ i)] (b : (i : ι) → Module.Basis (κ i) R (M i))
(a : Module.Dual R (PiTensorProduct R fun i => M i... | null | true |
FractionalIdeal.ne_zero_of_mul_eq_one | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R₁ : Type u_3} [inst : CommRing R₁] {K : Type u_4} [inst_1 : Field K] [inst_2 : Algebra R₁ K]
(I J : FractionalIdeal (nonZeroDivisors R₁) K), I * J = 1 → I ≠ 0 | null | true |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution.x_mul_y_mul_z_eq_u_mul_w_cube._simp_1_8 | Mathlib.NumberTheory.FLT.Three | ∀ {K : Type u_1} [inst : Field K] {ζ : K} {hζ : IsPrimitiveRoot ζ 3} (S : FermatLastTheoremForThreeGen.Solution✝ hζ)
[inst_1 : NumberField K] [inst_2 : IsCyclotomicExtension {3} ℚ K],
(hζ.toInteger - 1) ^ (3 * FermatLastTheoremForThreeGen.Solution.multiplicity✝ S - 2) *
FermatLastTheoremForThreeGen.Solution.x... | null | false |
Matrix.isUnit_charpolyRev_of_isNilpotent | Mathlib.LinearAlgebra.Matrix.Charpoly.Coeff | ∀ {R : Type u} [inst : CommRing R] {n : Type v} [inst_1 : DecidableEq n] [inst_2 : Fintype n] {M : Matrix n n R},
IsNilpotent M → IsUnit M.charpolyRev | null | true |
Polynomial.natDegree_mul_C_eq_of_mul_ne_zero | Mathlib.Algebra.Polynomial.Degree.Lemmas | ∀ {R : Type u} {a : R} [inst : Semiring R] {p : Polynomial R},
p.leadingCoeff * a ≠ 0 → (p * Polynomial.C a).natDegree = p.natDegree | Although not explicitly stated, the assumptions of lemma `natDegree_mul_C_eq_of_mul_ne_zero`
force the polynomial `p` to be non-zero, via `p.leadingCoeff ≠ 0`.
| true |
Std.ExtTreeSet.forM_eq_forM_toList | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} {m : Type w → Type w'} [inst : Std.TransCmp cmp]
[inst_1 : Monad m] [inst_2 : LawfulMonad m] {f : α → m PUnit.{w + 1}}, forM t f = t.toList.forM f | null | true |
PartialEquiv.transEquiv._proof_2 | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_2} (e : PartialEquiv α β) (f' : β ≃ γ),
↑(e.trans f'.toPartialEquiv).symm = ↑(e.trans f'.toPartialEquiv).symm | null | false |
Lean.Elab.ExpandDeclIdResult._sizeOf_inst | Lean.Elab.DeclModifiers | SizeOf Lean.Elab.ExpandDeclIdResult | null | false |
Lean.Meta.Simp.Stats.diag | Lean.Meta.Tactic.Simp.Types | Lean.Meta.Simp.Stats → Lean.Meta.Simp.Diagnostics | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.0.Int64.isValue._regBuiltin.Int64.isValue.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.4041591762._hygCtx._hyg.3 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit | null | false |
_private.Mathlib.Lean.Expr.Basic.0.Lean.Expr.isConstantApplication.aux.match_1 | Mathlib.Lean.Expr.Basic | (motive : Lean.Expr → ℕ → Sort u_1) →
(x : Lean.Expr) →
(x_1 : ℕ) →
((binderName : Lean.Name) →
(binderType b : Lean.Expr) →
(binderInfo : Lean.BinderInfo) →
(n : ℕ) → motive (Lean.Expr.lam binderName binderType b binderInfo) n.succ) →
((e : Lean.Expr) → motive e ... | null | false |
Homeomorph.toEquiv_piCongrLeft | Mathlib.Topology.Homeomorph.Lemmas | ∀ {ι : Type u_7} {ι' : Type u_8} {Y : ι' → Type u_9} [inst : (j : ι') → TopologicalSpace (Y j)] (e : ι ≃ ι'),
(Homeomorph.piCongrLeft e).toEquiv = Equiv.piCongrLeft Y e | null | true |
Stream'.cons_injective2 | Mathlib.Data.Stream.Init | ∀ {α : Type u}, Function.Injective2 Stream'.cons | null | true |
Lean.Grind.CommRing.Poly.combine.go.match_1.congr_eq_4 | Init.Grind.Ring.CommSolver | ∀ (motive : Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly → Sort u_1) (p₁ p₂ : Lean.Grind.CommRing.Poly)
(h_1 : (k₁ k₂ : ℤ) → motive (Lean.Grind.CommRing.Poly.num k₁) (Lean.Grind.CommRing.Poly.num k₂))
(h_2 :
(k₁ k₂ : ℤ) →
(m₂ : Lean.Grind.CommRing.Mon) →
(p₂ : Lean.Grind.CommRing.Poly) →
... | null | true |
DirectSum.decomposeLinearEquiv_apply | Mathlib.Algebra.DirectSum.Decomposition | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} [inst : DecidableEq ι] [inst_1 : Semiring R] [inst_2 : AddCommMonoid M]
[inst_3 : Module R M] (ℳ : ι → Submodule R M) [inst_4 : DirectSum.Decomposition ℳ] (m : M),
(DirectSum.decomposeLinearEquiv ℳ) m = (DirectSum.decompose ℳ) m | null | true |
Nat.toInt32 | Init.Data.SInt.Basic | ℕ → Int32 | Converts a natural number to a 32-bit signed integer, wrapping around to negative numbers on
overflow.
Examples:
* `Nat.toInt32 127 = 127`
* `Nat.toInt32 32770 = 32770`
* `Nat.toInt32 2_147_483_647 = 2_147_483_647`
* `Nat.toInt32 2_147_483_648 = -2_147_483_648`
| true |
ContinuousLinearMap.compContinuousMultilinearMapL._proof_1 | Mathlib.Topology.Algebra.Module.Multilinear.Topology | ∀ (𝕜 : Type u_4) {ι : Type u_1} (E : ι → Type u_2) (F : Type u_5) (G : Type u_3) [inst : NormedField 𝕜]
[inst_1 : (i : ι) → TopologicalSpace (E i)] [inst_2 : (i : ι) → AddCommGroup (E i)]
[inst_3 : (i : ι) → Module 𝕜 (E i)] [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F] [inst_6 : TopologicalSpace F]
[inst_7 ... | null | false |
Rep.instLinearResFunctor | Mathlib.RepresentationTheory.Rep.Res | ∀ {G : Type v1} {H : Type v2} [inst : Monoid G] [inst_1 : Monoid H] (f : H →* G) {k : Type u} [inst_2 : CommSemiring k],
CategoryTheory.Functor.Linear k (Rep.resFunctor f) | null | true |
Std.Time.DateTime.ofPlainDateTime | Std.Time.Zoned.DateTime | Std.Time.PlainDateTime → (tz : Std.Time.TimeZone) → Std.Time.DateTime tz | Creates a new `DateTime` out of a `PlainDateTime`. It assumes that the `PlainDateTime` is the Local
date time.
| true |
SeparationQuotient.instAddSemigroup.eq_1 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {M : Type u_1} [inst : TopologicalSpace M] [inst_1 : AddSemigroup M] [inst_2 : ContinuousAdd M],
SeparationQuotient.instAddSemigroup = { toAdd := SeparationQuotient.instAdd, add_assoc := ⋯ } | null | true |
NumberField.instCommRingAdeleRing._proof_30 | Mathlib.NumberTheory.NumberField.AdeleRing | ∀ (R : Type u_1) (K : Type u_2) [inst : CommRing R] [inst_1 : IsDedekindDomain R] [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K], autoParam (↑0 = 0) AddMonoidWithOne.natCast_zero._autoParam | null | false |
CommRingCat.Colimits.descMorphism._proof_4 | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CommRingCat)
(s : CategoryTheory.Limits.Cocone F), CommRingCat.Colimits.descFun F s 0 = CommRingCat.Colimits.descFun F s 0 | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.