name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Matroid.exists_isBasis._auto_1 | Mathlib.Combinatorics.Matroid.Basic | Lean.Syntax | null | false |
AddSubmonoid.comap_surjective_of_injective | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {F : Type u_4}
[inst_2 : FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F},
Function.Injective ⇑f → Function.Surjective (AddSubmonoid.comap f) | null | true |
Nat.count_eq_card_filter_range | Mathlib.Data.Nat.Count | ∀ (p : ℕ → Prop) [inst : DecidablePred p] (n : ℕ), Nat.count p n = {x ∈ Finset.range n | p x}.card | null | true |
ContinuousAffineEquiv.instEquivLike._proof_2 | Mathlib.Topology.Algebra.ContinuousAffineEquiv | ∀ {k : Type u_1} {P₁ : Type u_2} {P₂ : Type u_3} {V₁ : Type u_4} {V₂ : Type u_5} [inst : Ring k]
[inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁] [inst_3 : AddTorsor V₁ P₁] [inst_4 : TopologicalSpace P₁]
[inst_5 : AddCommGroup V₂] [inst_6 : Module k V₂] [inst_7 : AddTorsor V₂ P₂] [inst_8 : TopologicalSpace P₂]
(... | null | false |
CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.inverse_map_left_left | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor T D) (Y : D) (X : T)
{X_1 Y_1 : CategoryTheory.CostructuredArrow ((CategoryTheory.Over.forget X).comp F) Y} (g : X_1 ⟶ Y_1),
((CategoryTheory.CostructuredArrow.ofCost... | null | true |
Turing.PartrecToTM2.instDecidableEqCont'.decEq._proof_2 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (a : Turing.PartrecToTM2.Cont'), a.cons₂ = a.cons₂ | null | false |
Filter.NeBot.coprodᵢ | Mathlib.Order.Filter.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} [∀ (i : ι), Nonempty (α i)] {i : ι},
(f i).NeBot → (Filter.coprodᵢ f).NeBot | null | true |
Convexity.ConvexSpace.AffineMap.mk.inj | Mathlib.Geometry.Convex.ConvexSpace.AffineMap | ∀ {R : Type u_1} {inst : PartialOrder R} {inst_1 : Semiring R} {inst_2 : IsStrictOrderedRing R} {X : Type u_2}
{Y : Type u_3} {inst_3 : Convexity.ConvexSpace R X} {inst_4 : Convexity.ConvexSpace R Y} {toFun : X → Y}
{isAffineMap_toFun :
autoParam (Convexity.IsAffineMap R toFun) Convexity.ConvexSpace.AffineMap.i... | null | true |
Lean.Linter.UnusedVariables.FVarDefinition.noConfusion | Lean.Linter.UnusedVariables | {P : Sort u} →
{t t' : Lean.Linter.UnusedVariables.FVarDefinition} →
t = t' → Lean.Linter.UnusedVariables.FVarDefinition.noConfusionType P t t' | null | false |
PiTensorProduct.instSemiring._proof_11 | Mathlib.RingTheory.PiTensorProduct | ∀ {ι : Type u_1} {R : Type u_2} {A : ι → Type u_3} [inst : CommSemiring R] [inst_1 : (i : ι) → Semiring (A i)]
[inst_2 : (i : ι) → Algebra R (A i)] (a b c : PiTensorProduct R fun i => A i), (a + b) * c = a * c + b * c | null | false |
_private.Mathlib.Data.Ordmap.Invariants.0.Ordnode.splitMin'.match_1.splitter | Mathlib.Data.Ordmap.Invariants | {α : Type u_1} →
(motive : α × Ordnode α → Sort u_2) → (x : α × Ordnode α) → ((xm : α) → (l' : Ordnode α) → motive (xm, l')) → motive x | null | true |
Finset.nsmul | Mathlib.Algebra.Group.Pointwise.Finset.Basic | {α : Type u_2} → [DecidableEq α] → [Zero α] → [Add α] → SMul ℕ (Finset α) | Repeated pointwise addition (not the same as pointwise repeated addition!) of a `Finset`. See
note [pointwise nat action]. | true |
MulPosReflectLE.toMulPosReflectLT | Mathlib.Algebra.Order.GroupWithZero.Basic | ∀ {α : Type u_1} [inst : MulZeroClass α] [inst_1 : PartialOrder α] [MulPosReflectLE α], MulPosReflectLT α | null | true |
BitVec.intMin_sle | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x : BitVec w), (BitVec.intMin w).sle x = true | null | true |
Std.Time.Formats.leanDate | Std.Time.Format | Std.Time.GenericFormat Std.Time.Awareness.any | The Lean Date format, which follows the pattern `uuuu-MM-dd`. It uses the default value that can be parsed with the
notation of dates.
| true |
AlgebraicGeometry.Scheme.Pullback.pullbackFstιToV_snd | Mathlib.AlgebraicGeometry.Pullbacks | ∀ {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z)
[inst : ∀ (i : 𝒰.I₀), CategoryTheory.Limits.HasPullback (CategoryTheory.CategoryStruct.comp (𝒰.f i) f) g]
(i j : 𝒰.I₀),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.Pullback.pullbackFstιToV 𝒰 f g i j)
(Catego... | null | true |
Set.mem_finsetSum | Mathlib.Algebra.Group.Pointwise.Set.BigOperators | ∀ {ι : Type u_1} {α : Type u_2} [inst : AddCommMonoid α] (t : Finset ι) (f : ι → Set α) (a : α),
a ∈ ∑ i ∈ t, f i ↔ ∃ g, ∃ (_ : ∀ {i : ι}, i ∈ t → g i ∈ f i), ∑ i ∈ t, g i = a | The n-ary version of `Set.mem_add`. | true |
MvPolynomial.supported_le_supported_iff._simp_1 | Mathlib.Algebra.MvPolynomial.Supported | ∀ {σ : Type u_1} {R : Type u} [inst : CommSemiring R] {s t : Set σ} [Nontrivial R],
(MvPolynomial.supported R s ≤ MvPolynomial.supported R t) = (s ⊆ t) | null | false |
Complex.ofReal_one | Mathlib.Basic.Complex.Basic | ↑1 = 1 | null | true |
Metric.preimage_mul_left_closedEBall | Mathlib.Topology.MetricSpace.IsometricSMul | ∀ {G : Type v} [inst : Group G] [inst_1 : PseudoEMetricSpace G] [IsIsometricSMul G G] (a b : G) (r : ENNReal),
(fun x => a * x) ⁻¹' Metric.closedEBall b r = Metric.closedEBall (a⁻¹ * b) r | null | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.msb_srem._simp_1_6 | Init.Data.BitVec.Bitblast | ∀ {p : Prop} {x : Decidable p}, (decide p = false) = ¬p | null | false |
_private.Mathlib.RingTheory.MvPowerSeries.Equiv.0.MvPowerSeries.optionEquivLeft_X_none._simp_1_1 | Mathlib.RingTheory.MvPowerSeries.Equiv | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] (s : σ),
(MvPowerSeries.monomial fun₀ | s => 1) 1 = MvPowerSeries.X s | null | false |
Lean.Compiler.LCNF.CompilerM.Context.noConfusionType | Lean.Compiler.LCNF.CompilerM | Sort u → Lean.Compiler.LCNF.CompilerM.Context → Lean.Compiler.LCNF.CompilerM.Context → Sort u | null | false |
Multiset.decidableDexistsMultiset._proof_1 | Mathlib.Data.Multiset.Defs | ∀ {α : Type u_1} {m : Multiset α} {p : (a : α) → a ∈ m → Prop}, (∃ x ∈ m.attach, p ↑x ⋯) ↔ ∃ a, ∃ (h : a ∈ m), p a h | null | false |
ExteriorAlgebra.ι_eq_zero_iff._simp_1 | Mathlib.LinearAlgebra.ExteriorAlgebra.Basic | ∀ {R : Type u1} [inst : CommRing R] {M : Type u2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] (x : M),
((ExteriorAlgebra.ι R) x = 0) = (x = 0) | null | false |
_private.Mathlib.Order.Filter.Ker.0.Filter.giPrincipalKer._simp_1 | Mathlib.Order.Filter.Ker | ∀ {α : Type u} {s : Set α} {f : Filter α}, (Filter.principal s ≤ f) = ∀ V ∈ f, s ⊆ V | null | false |
_private.Std.Data.DHashMap.Lemmas.0.Std.DHashMap.get?_insertIfNew._simp_1_1 | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} {a : α},
(a ∈ m) = (m.contains a = true) | null | false |
Std.Iterators.HetT.bind._proof_3 | Std.Data.Iterators.Lemmas.Equivalence.HetT | ∀ {m : Type u_1 → Type u_4} {α : Type u_3} {β : Type u_2} (x : Std.Iterators.HetT m α) (f : α → Std.Iterators.HetT m β),
Std.Internal.Small { b // ∃ a, x.Property a ∧ (f a).Property b } →
Std.Internal.Small { b // ∃ a, x.Property a ∧ (f a).Property b } | null | false |
iSup_himp_eq | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u} {ι : Sort w} [inst : Order.Frame α] {a : α} {f : ι → α}, (⨆ x, f x) ⇨ a = ⨅ x, f x ⇨ a | null | true |
Std.IterM.DefaultConsumers.forIn'_eq_match_step | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | ∀ {α β : Type w} {m : Type w → Type w'} [inst : Std.Iterator α m β] {n : Type x → Type x'} [inst_1 : Monad n]
[LawfulMonad n] {lift : (γ : Type w) → (δ : Type x) → (γ → n δ) → m γ → n δ} {γ : Type x} {it : Std.IterM m β}
{init : γ} {P : β → Prop} {hP : ∀ (b : β), it.IsPlausibleIndirectOutput b → P b}
(PlausibleFo... | null | true |
_private.Mathlib.Algebra.Order.Module.Field.0.Mathlib.Meta.Positivity.evalSMul._sparseCasesOn_9 | Mathlib.Algebra.Order.Module.Field | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
Finset.inf'_sup_distrib_right | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_2} {ι : Type u_5} [inst : DistribLattice α] {s : Finset ι} (hs : s.Nonempty) (f : ι → α) (a : α),
s.inf' hs f ⊔ a = s.inf' hs fun i => f i ⊔ a | null | true |
Valuation.IsUniformizer.val_lt_one | Mathlib.RingTheory.Valuation.Discrete.Basic | ∀ {Γ : Type u_1} [inst : LinearOrderedCommGroupWithZero Γ] {A : Type u_2} [inst_1 : Ring A] {v : Valuation A Γ}
[hv : v.IsRankOneDiscrete] {π : A}, v.IsUniformizer π → v π < 1 | null | true |
Real.cos_two_mul_eq_one_sub | Mathlib.Analysis.Complex.Trigonometric | ∀ (x : ℝ), Real.cos (2 * x) = 1 - 2 * Real.sin x ^ 2 | null | true |
OrderMonoidHom.comp_apply | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
[inst_3 : MulOneClass α] [inst_4 : MulOneClass β] [inst_5 : MulOneClass γ] (f : β →*o γ) (g : α →*o β) (a : α),
(f.comp g) a = f (g a) | null | true |
CategoryTheory.Limits.PreservesCofilteredLimitsOfSize.mk._flat_ctor | Mathlib.CategoryTheory.Limits.Preserves.Filtered | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D},
(∀ (J : Type w) [inst_2 : CategoryTheory.Category.{w', w} J] [CategoryTheory.IsCofiltered J],
CategoryTheory.Limits.PreservesLimitsOfShape J F) →
Catego... | null | false |
_private.Mathlib.Algebra.Group.Action.Faithful.0.FaithfulSMul.trans._simp_1_1 | Mathlib.Algebra.Group.Action.Faithful | ∀ (R : Type u_4) (A : Type u_5) [inst : MulOneClass A] [inst_1 : SMul R A] [IsScalarTower R A A],
FaithfulSMul R A = Function.Injective fun r => r • 1 | null | false |
TopCat.uliftFunctorFullyFaithful._proof_1 | Mathlib.Topology.Category.TopCat.ULift | ∀ {X Y : TopCat} (f : TopCat.uliftFunctor.obj X ⟶ TopCat.uliftFunctor.obj Y),
Continuous (ULift.down ∘ ⇑(CategoryTheory.ConcreteCategory.hom f) ∘ ULift.up) | null | false |
Lean.Meta.ParamInfo.backDeps | Lean.Meta.Basic | Lean.Meta.ParamInfo → Array ℕ | `backDeps` contains the backwards dependencies. That is, the (0-indexed) position of previous parameters that this one depends on. | true |
OrderType.instNontrivial | Mathlib.Order.Types.Defs | Nontrivial OrderType.{u} | null | true |
LinearMap.BilinForm.dualSubmoduleToDual._proof_3 | Mathlib.LinearAlgebra.BilinearForm.DualLattice | ∀ {R : Type u_2} {S : Type u_1} {M : Type u_3} [inst : CommRing R] [inst_1 : Field S] [inst_2 : AddCommGroup M]
[inst_3 : Algebra R S] [inst_4 : Module R M] [inst_5 : Module S M] [inst_6 : IsScalarTower R S M]
(B : LinearMap.BilinForm S M) (N : Submodule R M) (x : ↥(B.dualSubmodule N)) (r : R) (m : ↥N),
(algebraM... | null | false |
_private.Mathlib.Order.ConditionallyCompleteLattice.Basic.0.MonotoneOn.csInf_eq_of_subset_of_forall_exists_le._simp_1_2 | Mathlib.Order.ConditionallyCompleteLattice.Basic | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y | null | false |
CategoryTheory.BasedNatTrans.comp_toNatTrans | Mathlib.CategoryTheory.FiberedCategory.BasedCategory | ∀ {𝒮 : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] {𝒳 : CategoryTheory.BasedCategory 𝒮}
{𝒴 : CategoryTheory.BasedCategory 𝒮} {F G H : CategoryTheory.BasedFunctor 𝒳 𝒴} (α : CategoryTheory.BasedNatTrans F G)
(β : CategoryTheory.BasedNatTrans G H), (α.comp β).toNatTrans = α.vcomp β.toNatTrans | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Log.PosLog.0.Real.monotoneOn_posLog._proof_1_1 | Mathlib.Analysis.SpecialFunctions.Log.PosLog | ∀ ⦃x : ℝ⦄, x ∈ Set.Ici (-1) → ∀ ⦃y : ℝ⦄, x ≤ y → x.posLog ≤ y.posLog | null | false |
Option.getD.eq_2 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} (dflt : α), none.getD dflt = dflt | null | true |
Filter.Eventually.choice | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {β : Type v} {r : α → β → Prop} {l : Filter α} [l.NeBot],
(∀ᶠ (x : α) in l, ∃ y, r x y) → ∃ f, ∀ᶠ (x : α) in l, r x (f x) | null | true |
MulActionHom.instAddZeroClass | Mathlib.GroupTheory.GroupAction.Hom | {M : Type u_2} →
{N : Type u_3} →
{X : Type u_4} →
{Y : Type u_5} →
{σ : M → N} →
[inst : SMul M X] → [inst_1 : AddZeroClass Y] → [inst_2 : DistribSMul N Y] → AddZeroClass (X →ₑ[σ] Y) | null | true |
CategoryTheory.prodFunctorToFunctorProd_obj | Mathlib.CategoryTheory.Products.Basic | ∀ (A : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} A] (B : Type u₂) [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
(C : Type u₃) [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
(F : CategoryTheory.Functor A B × CategoryTheory.Functor A C),
(CategoryTheory.prodFunctorToFunctorProd A B C).obj F = F.1.prod' F.2 | null | true |
_private.Batteries.Data.Random.MersenneTwister.0.Batteries.Random.MersenneTwister.State.twist._proof_4 | Batteries.Data.Random.MersenneTwister | ∀ {cfg : Batteries.Random.MersenneTwister.Config} (state : Batteries.Random.MersenneTwister.State cfg),
↑state.index < cfg.stateSize | null | false |
Lean.PersistentHashMap.Node._sizeOf_2_eq | Lean.Data.PersistentHashMap | ∀ {α : Type u} {β : Type v} [inst : SizeOf α] [inst_1 : SizeOf β]
(x : Array (Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β))),
Lean.PersistentHashMap.Node._sizeOf_2 x = sizeOf x | null | false |
ProofWidgets.RefreshComponent.AwaitRefreshParams.noConfusion | ProofWidgets.Component.RefreshComponent | {P : Sort u} →
{t t' : ProofWidgets.RefreshComponent.AwaitRefreshParams} →
t = t' → ProofWidgets.RefreshComponent.AwaitRefreshParams.noConfusionType P t t' | null | false |
CategoryTheory.MorphismProperty.Under.instHasInitialTopOfContainsIdentities | Mathlib.CategoryTheory.Limits.MorphismProperty | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} T] (P : CategoryTheory.MorphismProperty T) (X : T)
[P.ContainsIdentities], CategoryTheory.Limits.HasInitial (P.Under ⊤ X) | null | true |
List.toFinset_range'_1 | Mathlib.Order.Interval.Finset.Nat | ∀ (a b : ℕ), (List.range' a b).toFinset = Finset.Ico a (a + b) | null | true |
HomotopicalAlgebra.fibration_unop_iff | Mathlib.AlgebraicTopology.ModelCategory.CategoryWithCofibrations | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.CategoryWithFibrations C]
{X Y : Cᵒᵖ} (f : X ⟶ Y), HomotopicalAlgebra.Fibration f.unop ↔ HomotopicalAlgebra.Cofibration f | null | true |
MeasureTheory.Measure.mkMetric_mono | Mathlib.MeasureTheory.Measure.Hausdorff | ∀ {X : Type u_2} [inst : EMetricSpace X] [inst_1 : MeasurableSpace X] [inst_2 : BorelSpace X]
{m₁ m₂ : ENNReal → ENNReal}, m₁ ≤ᶠ[nhds 0] m₂ → MeasureTheory.Measure.mkMetric m₁ ≤ MeasureTheory.Measure.mkMetric m₂ | If `m₁ d ≤ m₂ d` for `d < ε` for some `ε > 0` (we use `≤ᶠ[𝓝 0]` to state this), then
`mkMetric m₁ hm₁ ≤ mkMetric m₂ hm₂`. | true |
CategoryTheory.InjectiveResolution.descFOne._proof_1 | Mathlib.CategoryTheory.Abelian.Injective.Resolution | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C] {Z : C}
(J : CategoryTheory.InjectiveResolution Z), CategoryTheory.CategoryStruct.comp (J.ι.f 0) (J.cocomplex.d 0 1) = 0 | null | false |
Lean.Grind.CommRing.Poly.combine.go.eq_1 | Init.Grind.Ring.CommSolver | ∀ (p₁ p₂ : Lean.Grind.CommRing.Poly), Lean.Grind.CommRing.Poly.combine.go 0 p₁ p₂ = p₁.concat p₂ | null | true |
_private.Mathlib.Tactic.ComputeAsymptotics.Multiseries.Monomial.Basic.0.Tactic.ComputeAsymptotics.UnitMonomial.isLittleO_of_lt._simp_1_7 | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Monomial.Basic | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False | null | false |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.match_48 | Std.Sat.AIG.CNF | (aig : Std.Sat.AIG ℕ) →
(upper : ℕ) →
(h : upper < aig.decls.size) →
(cond ifTrue ifFalse : Std.Sat.AIG.Fanin) →
(hltf : ifFalse.gate < upper) →
(tstate : Std.Sat.AIG.toCNF.State✝ aig) →
(motive : { out // Std.Sat.AIG.toCNF.State.IsExtensionBy✝ tstate out ifFalse.gate ⋯ } → Sor... | null | false |
Std.Internal.UV.System.PasswdInfo.casesOn | Std.Internal.UV.System | {motive : Std.Internal.UV.System.PasswdInfo → Sort u} →
(t : Std.Internal.UV.System.PasswdInfo) →
((username : String) →
(uid gid : Option UInt64) →
(shell homedir : Option String) →
motive { username := username, uid := uid, gid := gid, shell := shell, homedir := homedir }) →
... | null | false |
cfcHom.congr_simp | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | ∀ {R : Type u_1} {A : Type u_2} {p p_1 : A → Prop} (e_p : p = p_1) [inst : CommSemiring 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] [instCFC : ContinuousF... | null | true |
ProofWidgets.Penrose.DiagramProps.embeds | ProofWidgets.Component.PenroseDiagram | ProofWidgets.Penrose.DiagramProps → Array (String × ProofWidgets.Html) | null | true |
ArithmeticFunction.carmichael_mul | Mathlib.NumberTheory.ArithmeticFunction.Carmichael | ∀ {a b : ℕ},
a.Coprime b →
ArithmeticFunction.carmichael (a * b) = (ArithmeticFunction.carmichael a).lcm (ArithmeticFunction.carmichael b) | null | true |
inv_nonpos' | Mathlib.Algebra.Order.Field.Basic | ∀ {α : Type u_1} [inst : Field α] [inst_1 : PartialOrder α] [PosMulReflectLT α] [IsStrictOrderedRing α] {a : α},
a⁻¹ ≤ 0 ↔ a ≤ 0 | A version of `inv_nonpos` which holds with different assumptions. In particular, the type
must be a field, not just a `GroupWithZero`, but the order assumptions replace `LinearOrder` and
`PosMulMono` with `PartialOrder`, `IsStrictOrderedRing` and `PosMulReflectLT`. Thus neither version
is more general than the other. T... | true |
Std.Http.URI.Builder.setPort | Std.Http.Data.URI.Basic | Std.Http.URI.Builder → UInt16 → Std.Http.URI.Builder | Sets the port number.
| true |
_private.Mathlib.MeasureTheory.Covering.Besicovitch.0.Mathlib.Meta.Positivity.evalBesicovitchSatelliteConfigR._sparseCasesOn_1 | Mathlib.MeasureTheory.Covering.Besicovitch | {motive : Lean.Level → Sort u} →
(t : Lean.Level) → motive Lean.Level.zero → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
InnerProductSpace.Core.inner_self_ne_zero | Mathlib.Analysis.InnerProductSpace.Defs | ∀ {𝕜 : Type u_1} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
[cd : InnerProductSpace.Core 𝕜 F] {x : F}, inner 𝕜 x x ≠ 0 ↔ x ≠ 0 | null | true |
CategoryTheory.Grp.instGrpObj._proof_2 | 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.CartesianMonoidalCategory.l... | null | false |
MulRingNorm.mulRingNormEquivAbsoluteValue.congr_simp | Mathlib.Analysis.Normed.Unbundled.SpectralNorm | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : Nontrivial R],
MulRingNorm.mulRingNormEquivAbsoluteValue = MulRingNorm.mulRingNormEquivAbsoluteValue | null | true |
_private.Mathlib.Algebra.Homology.SpectralObject.Basic.0.CategoryTheory.Abelian.SpectralObject._proof_9 | Mathlib.Algebra.Homology.SpectralObject.Basic | 0 ≤ 0 | null | false |
IsFractionRing.definition._proof_1._@.Mathlib.RingTheory.Localization.FractionRing.1935392398._hygCtx._hyg.2 | Mathlib.RingTheory.Localization.FractionRing | ∀ (A : Type u_1) [inst : CommRing A] {K : Type u_2} [inst_1 : CommRing K] [inst_2 : Algebra A K]
[inst_3 : IsFractionRing A K] [IsDomain A] (z : K),
¬z = 0 → (IsLocalization.sec (nonZeroDivisors A) z).1 ∈ nonZeroDivisors A | null | false |
HShiftRight.mk | Init.Prelude | {α : Type u} → {β : Type v} → {γ : outParam (Type w)} → (α → β → γ) → HShiftRight α β γ | null | true |
CategoryTheory.Limits.CatCospanTransform.«_aux_Mathlib_CategoryTheory_Limits_Shapes_Pullback_Categorical_CatCospanTransform___macroRules_CategoryTheory_Limits_CatCospanTransform_termλ__1» | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | Lean.Macro | null | false |
LinearPMap.sSup_apply | Mathlib.LinearAlgebra.LinearPMap | ∀ {R : Type u_1} {S : Type u_2} [inst : Ring R] [inst_1 : Ring S] {σ : R →+* S} {E : Type u_4} [inst_2 : AddCommGroup E]
[inst_3 : Module R E] {F : Type u_5} [inst_4 : AddCommGroup F] [inst_5 : Module S F] {c : Set (E →ₛₗ.[σ] F)}
(hc : DirectedOn (fun x1 x2 => x1 ≤ x2) c) {l : E →ₛₗ.[σ] F} (hl : l ∈ c) (x : ↥l.doma... | null | true |
Module.subsingletonEquiv._proof_3 | Mathlib.LinearAlgebra.Finsupp.Defs | ∀ (R : Type u_1) (M : Type u_3) (ι : Type u_2) [inst : Semiring R] (r : R) (x : M), 0 = r • 0 | null | false |
AffineBasis.sum_coord_apply_eq_one | Mathlib.LinearAlgebra.AffineSpace.Basis | ∀ {ι : Type u_1} {k : Type u_5} {V : Type u_6} {P : Type u_7} [inst : AddCommGroup V] [inst_1 : AddTorsor V P]
[inst_2 : Ring k] [inst_3 : Module k V] (b : AffineBasis ι k P) [inst_4 : Fintype ι] (q : P), ∑ i, (b.coord i) q = 1 | null | true |
CategoryTheory.ObjectProperty.instPretriangulatedFullSubcategory._proof_7 | Mathlib.CategoryTheory.Triangulated.Subcategory | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(P : CategoryT... | null | false |
Qq.Impl.ExprBackSubstResult.unquoted.injEq | Qq.Macro | ∀ (e e_1 : Lean.Expr), (Qq.Impl.ExprBackSubstResult.unquoted e = Qq.Impl.ExprBackSubstResult.unquoted e_1) = (e = e_1) | null | true |
_private.Lean.Meta.Tactic.Grind.Internalize.0.Lean.Meta.Grind.internalizeImpl.go.match_1 | Lean.Meta.Tactic.Grind.Internalize | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((deBruijnIndex : ℕ) → motive (Lean.Expr.bvar deBruijnIndex)) →
((u : Lean.Level) → motive (Lean.Expr.sort u)) →
((fvarId : Lean.FVarId) → motive (Lean.Expr.fvar fvarId)) →
((declName : Lean.Name) →
(type value body : Lean.E... | null | false |
Set.smul_mem_smul_set_iff₀._simp_1 | Mathlib.Algebra.GroupWithZero.Action.Pointwise.Set | ∀ {α : Type u_1} {β : Type u_2} [inst : GroupWithZero α] [inst_1 : MulAction α β] {a : α},
a ≠ 0 → ∀ (A : Set β) (x : β), (a • x ∈ a • A) = (x ∈ A) | null | false |
Subgroup.goursat | Mathlib.GroupTheory.Goursat | ∀ {G : Type u_1} {H : Type u_2} [inst : Group G] [inst_1 : Group H] {I : Subgroup (G × H)},
∃ G' H' M N,
∃ (x : M.Normal) (x_1 : N.Normal),
∃ e,
I =
Subgroup.map (G'.subtype.prodMap H'.subtype)
(Subgroup.comap ((QuotientGroup.mk' M).prodMap (QuotientGroup.mk' N)) e.toMonoidHom.... | **Goursat's lemma** for an arbitrary subgroup.
If `I` is a subgroup of `G × H`, then there exist subgroups `G' ≤ G`, `H' ≤ H` and normal subgroups
`M ⊴ G'` and `N ⊴ H'` such that `M × N ≤ I` and the image of `I` in `G' ⧸ M × H' ⧸ N` is the graph
of an isomorphism `G' ⧸ M ≃ H' ⧸ N`. | true |
Std.DTreeMap.Internal.Impl.insertMin! | Std.Data.DTreeMap.Internal.Operations | {α : Type u} → {β : α → Type v} → (k : α) → β k → Std.DTreeMap.Internal.Impl α β → Std.DTreeMap.Internal.Impl α β | Slower version of `insertMin` which can be used in the absence of balance information but
still assumes the preconditions of `insertMin`, otherwise might panic.
| true |
Lean.Meta.Grind.EMatchDiagNode | Lean.Meta.Tactic.Grind.Types | Type | A node in the E-matching diagnostics hyper-graph.
| true |
NNNorm.recOn | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_4} →
{motive : NNNorm E → Sort u} → (t : NNNorm E) → ((nnnorm : E → NNReal) → motive { nnnorm := nnnorm }) → motive t | null | false |
LocallyFinite.comp_injOn | Mathlib.Topology.LocallyFinite | ∀ {ι : Type u_1} {ι' : Type u_2} {X : Type u_4} [inst : TopologicalSpace X] {f : ι → Set X} {g : ι' → ι},
LocallyFinite f → Set.InjOn g {i | (f (g i)).Nonempty} → LocallyFinite (f ∘ g) | null | true |
CategoryTheory.AddMon.snd_hom | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (M N : CategoryTheory.AddMon C),
(CategoryTheory.SemiCartesianMonoidalCategory.snd M N).hom = CategoryTheory.SemiCartesianMonoidalCategory.snd M.X N.X | null | true |
CategoryTheory.HasCardinalFilteredColimits.mk._flat_ctor | Mathlib.CategoryTheory.Presentable.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {κ : Cardinal.{w}} [inst_1 : Fact κ.IsRegular],
autoParam
(∀ (J : Type w) [inst_2 : CategoryTheory.SmallCategory J] [CategoryTheory.IsCardinalFiltered J κ],
CategoryTheory.Limits.HasColimitsOfShape J C)
CategoryTheory.HasCardinalFilteredC... | null | false |
WittVector.instAdd | Mathlib.RingTheory.WittVector.Defs | {p : ℕ} → {R : Type u_1} → [hp : Fact (Nat.Prime p)] → [CommRing R] → Add (WittVector p R) | null | true |
mulLECancellable_mul._simp_2 | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} {a b : α} [inst : LE α] [inst_1 : CommSemigroup α] [MulLeftMono α],
MulLECancellable (a * b) = (MulLECancellable a ∧ MulLECancellable b) | null | false |
OrderDual.instOrderTopOfOrderBot | Mathlib.Order.BoundedOrder.Basic | (α : Type u) → [inst : LE α] → [h : OrderBot α] → OrderTop αᵒᵈ | null | true |
_private.Mathlib.CategoryTheory.Limits.ConstructLimitMap.0.CategoryTheory.ConstructLimitMap.map._proof_1 | Mathlib.CategoryTheory.Limits.ConstructLimitMap | ∀ {C : Type u_6} [inst : CategoryTheory.Category.{u_3, u_6} C] {I : Type u_4}
[inst_1 : CategoryTheory.Category.{u_1, u_4} I] {I' : Type u_5} [inst_2 : CategoryTheory.Category.{u_2, u_5} I']
{D : CategoryTheory.Functor I C} {D' : CategoryTheory.Functor I' C} {c : CategoryTheory.Limits.Cone D}
{c' : CategoryTheory... | null | false |
Std.Symm.forall_existsUnique_iff' | Mathlib.Logic.Function.Basic | ∀ {α : Sort u_1} {r : α → α → Prop} [Std.Symm r],
(∀ (a : α), ∃! b, r a b) ↔ ∃ f, Function.Involutive f ∧ r = fun x1 x2 => f x1 = x2 | A symmetric relation `r : α → α → Prop` is "function-like"
(for each `a` there exists a unique `b` such that `r a b`)
if and only if it is `(f · = ·)` for some involutive function `f`. | true |
Finset.card_le_card_biUnion_add_one | Mathlib.Algebra.Order.BigOperators.Group.Finset | ∀ {ι : Type u_1} {α : Type u_2} [inst : DecidableEq α] {s : Finset ι} {f : ι → Finset α},
Function.Injective f → (↑s).PairwiseDisjoint f → s.card ≤ (s.biUnion f).card + 1 | null | true |
CategoryTheory.Limits.has_cokernel_pair_of_epi | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Mono | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Epi f],
CategoryTheory.Limits.HasPushout f f | null | true |
_private.Init.Data.List.Sort.Impl.0.List.MergeSort.Internal.mergeSortTR₂.run'.match_1 | Init.Data.List.Sort.Impl | {α : Type u_1} →
(n : ℕ) →
(motive : { l // l.length = (n + 2) / 2 } × { l // l.length = (n + 2 + 1) / 2 } → Sort u_2) →
(x : { l // l.length = (n + 2) / 2 } × { l // l.length = (n + 2 + 1) / 2 }) →
((l : { l // l.length = (n + 2) / 2 }) → (r : { l // l.length = (n + 2 + 1) / 2 }) → motive (l, r)) →... | null | false |
Mathlib.Tactic.Widget.StringDiagram.mkEqHtml | Mathlib.Tactic.Widget.StringDiagram | ProofWidgets.Html → ProofWidgets.Html → ProofWidgets.Html | Help function for displaying two string diagrams in an equality. | true |
Inclusion.IVar.recOn | Mathlib.Tactic.Inclusion.Core.Types | {motive : Inclusion.IVar → Sort u} →
(t : Inclusion.IVar) →
((iExpr : Inclusion.IExpr) →
(setVar hypVar : Lean.Expr) →
(cover? : Option Lean.Expr) →
motive { iExpr := iExpr, setVar := setVar, hypVar := hypVar, cover? := cover? }) →
motive t | null | false |
NNReal.agmSequences_zero | Mathlib.Analysis.SpecialFunctions.ArithmeticGeometricMean | ∀ {x y : NNReal}, x.agmSequences y 0 = (NNReal.sqrt (x * y), (x + y) / 2) | null | true |
CategoryTheory.CardinalDirectedPoset.propSet_singleton | Mathlib.CategoryTheory.Presentable.CardinalDirectedPoset | ∀ {κ : Cardinal.{u}} [inst : Fact κ.IsRegular] {J : CategoryTheory.CardinalDirectedPoset κ} (j : ↑J.obj), J.PropSet {j} | null | true |
Language.mem_sub | Mathlib.Computability.Language | ∀ {α : Type u_1} (l m : Language α) (x : List α), x ∈ l - m ↔ x ∈ l ∧ x ∉ m | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.