name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ProbabilityTheory.IsGaussian.noAtoms | Mathlib.Probability.Distributions.Gaussian.Fernique | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E] [BorelSpace E]
{μ : MeasureTheory.Measure E} [ProbabilityTheory.IsGaussian μ] [CompleteSpace E] [SecondCountableTopology E],
(∀ (x : E), μ ≠ MeasureTheory.Measure.dirac x) → MeasureTheory.NoAtoms μ | If a Gaussian measure is not a Dirac, then it has no atoms. | true |
AlgebraicGeometry.Scheme.Modules.pseudofunctor_mapComp_hom_τl | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {a b c : CategoryTheory.LocallyDiscrete AlgebraicGeometry.Schemeᵒᵖ} (x : a ⟶ b) (x_1 : b ⟶ c),
(AlgebraicGeometry.Scheme.Modules.pseudofunctor.mapComp x x_1).hom.τl =
CategoryTheory.NatTrans.toCatHom₂ (AlgebraicGeometry.Scheme.Modules.pullbackComp x_1.as.unop x.as.unop).inv | null | true |
_private.Mathlib.Algebra.Homology.ShortComplex.PreservesHomology.0.CategoryTheory.ShortComplex.LeftHomologyData.mapCyclesIso_eq._simp_1_1 | Mathlib.Algebra.Homology.ShortComplex.PreservesHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ S₃ : CategoryTheory.ShortComplex C} (φ₁ : S₁ ⟶ S₂) (φ₂ : S₂ ⟶ S₃) (h₁ : S₁.LeftHomologyData)
(h₂ : S₂.LeftHomologyData) (h₃ : S₃.LeftHomologyData),
CategoryTheory.CategoryStruct.comp (Category... | null | false |
MvPolynomial.sumSMulX | Mathlib.RingTheory.MvPolynomial.IrreducibleQuadratic | {n : Type u_1} → {R : Type u_2} → [inst : CommRing R] → (n →₀ R) →ₗ[R] MvPolynomial n R | The linear polynomial $$\sum_i c_i X_i$$. | true |
meromorphicNFAt_prod | Mathlib.Analysis.Meromorphic.NormalForm | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {ι : Type u_3} {s : Finset ι} {f : ι → 𝕜 → 𝕜},
(∀ i ∈ s, MeromorphicNFAt (f i) x) → {σ | σ ∈ s ∧ f σ x = 0}.Subsingleton → MeromorphicNFAt (∏ i ∈ s, f i) x | A product of meromorphic functions in normal form is in normal form if at most one of the factors
vanishes.
| true |
List.concat | Init.Prelude | {α : Type u} → List α → α → List α | Adds an element to the *end* of a list.
The added element is the last element of the resulting list.
Examples:
* `List.concat ["red", "yellow"] "green" = ["red", "yellow", "green"]`
* `List.concat [1, 2, 3] 4 = [1, 2, 3, 4]`
* `List.concat [] () = [()]`
| true |
_private.Init.Data.Int.Order.0.Int.add_le_add_left.match_1_1 | Init.Data.Int.Order | ∀ {a b : ℤ} (motive : (∃ n, a + ↑n = b) → Prop) (x : ∃ n, a + ↑n = b),
(∀ (n : ℕ) (hn : a + ↑n = b), motive ⋯) → motive x | null | false |
ReflBEq | Init.Core | (α : Type u_1) → [BEq α] → Prop | `ReflBEq α` says that the `BEq` implementation is reflexive. | true |
LaurentPolynomial.«term_[T;T⁻¹]» | Mathlib.Algebra.Polynomial.Laurent | Lean.TrailingParserDescr | null | true |
fderiv_eq_smul_deriv | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {x : 𝕜} (y : 𝕜), (fderiv 𝕜 f x) y = y • deriv f x | null | true |
MeasureTheory.Lp.edist_def | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_1} {E : Type u_4} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] (f g : ↥(MeasureTheory.Lp E p μ)), edist f g = MeasureTheory.eLpNorm (↑↑f - ↑↑g) p μ | null | true |
DirectLimit.Algebra.hom_ext | Mathlib.Algebra.Colimit.DirectLimit | ∀ {R : Type u_1} {ι : Type u_2} [inst : Preorder ι] {G : ι → Type u_3} {T : ⦃i j : ι⦄ → i ≤ j → Type u_6}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] [inst_4 : CommSemiri... | null | true |
Std.DHashMap.Const.getKey!_insertManyIfNewUnit_list_of_not_mem_of_contains_eq_false | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α fun x => Unit} [EquivBEq α] [LawfulHashable α]
[inst : Inhabited α] {l : List α} {k : α},
k ∉ m → l.contains k = false → (Std.DHashMap.Const.insertManyIfNewUnit m l).getKey! k = default | null | true |
Convert.ExpensiveConfig.rec | Mathlib.Tactic.Convert | {motive : Convert.ExpensiveConfig → Sort u} →
((toCheapConfig : Convert.CheapConfig) → motive { toCheapConfig := toCheapConfig }) →
(t : Convert.ExpensiveConfig) → motive t | null | false |
Aesop.ClusterState.rec | Aesop.Forward.State | {motive : Aesop.ClusterState → Sort u} →
((slots : Array Aesop.Slot) →
(conclusionDeps : Array Aesop.PremiseIndex) →
(variableMap : Aesop.VariableMap) →
(completeMatches : Lean.PHashSet Aesop.Match) →
(haveHypForEachSlot : Bool) →
(slotQueues : Array (Array Aesop.RawH... | null | false |
Lean.Meta.Grind.VarRename._sizeOf_inst | Lean.Meta.Tactic.Grind.VarRename | SizeOf Lean.Meta.Grind.VarRename | null | false |
mabs_le_mabs_of_one_le | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : Group α] {a b : α} [MulLeftMono α], 1 ≤ a → a ≤ b → |a|ₘ ≤ |b|ₘ | null | true |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.zero_lt_getElem!_toArray_ric_iff._simp_1_2 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, (m < n.succ) = (m ≤ n) | null | false |
prime_mul_iff | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] [IsCancelMulZero M] {x y : M},
Prime (x * y) ↔ Prime x ∧ IsUnit y ∨ IsUnit x ∧ Prime y | null | true |
RootPairing.RootPositiveForm.noConfusion | Mathlib.LinearAlgebra.RootSystem.RootPositive | {P : Sort u} →
{ι : Type u_1} →
{R : Type u_2} →
{S : Type u_3} →
{M : Type u_4} →
{N : Type u_5} →
{inst : CommRing S} →
{inst_1 : LinearOrder S} →
{inst_2 : CommRing R} →
{inst_3 : Algebra S R} →
{inst_4 : Ad... | null | false |
AlternatingMap.toMultilinearMap | Mathlib.LinearAlgebra.Alternating.Basic | {R : Type u_1} →
[inst : Semiring R] →
{M : Type u_2} →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
{N : Type u_3} →
[inst_3 : AddCommMonoid N] →
[inst_4 : Module R N] → {ι : Type u_7} → M [⋀^ι]→ₗ[R] N → MultilinearMap R (fun x => M) N | The multilinear map associated to an alternating map | true |
String._sizeOf_1.eq._@.Mathlib.Util.CompileInductive.3964927263._hygCtx._hyg.24 | Mathlib.Util.CompileInductive | String._sizeOf_1 = String._sizeOf_1✝ | null | false |
Std.Tactic.BVDecide.BoolExpr.eval_ite | Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic | ∀ {α : Type} {a : α → Bool} {d l r : Std.Tactic.BVDecide.BoolExpr α},
Std.Tactic.BVDecide.BoolExpr.eval a (d.ite l r) =
bif Std.Tactic.BVDecide.BoolExpr.eval a d then Std.Tactic.BVDecide.BoolExpr.eval a l
else Std.Tactic.BVDecide.BoolExpr.eval a r | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Traversal.0.SimpleGraph.Walk.getVert.match_1.eq_3 | Mathlib.Combinatorics.SimpleGraph.Walk.Traversal | ∀ {V : Type u_1} {G : SimpleGraph V} {u : V} (motive : (v : V) → G.Walk u v → ℕ → Sort u_2) (v v_1 : V)
(h : G.Adj u v_1) (q : G.Walk v_1 v) (n : ℕ) (h_1 : (x : ℕ) → motive u SimpleGraph.Walk.nil x)
(h_2 : (v v_2 : V) → (h : G.Adj u v_2) → (p : G.Walk v_2 v) → motive v (SimpleGraph.Walk.cons h p) 0)
(h_3 : (v v_2... | null | true |
AlgebraicGeometry.Scheme.IdealSheafData.instIdemCommSemiring._proof_3 | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme} (x : X.IdealSheafData), x ^ 0 = 1 | null | false |
groupHomology.H1ToTensorOfIsTrivial.match_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u_1, u_1, u_1} k G) (y : G →₀ ↑A)
(hy : y ∈ (groupHomology.cycles₁ A).toAddSubgroup)
(motive : ⟨y, hy⟩ ∈ (groupHomology.shortComplexH1 A).moduleCatToCycles.range.toAddSubgroup → Prop)
(x : ⟨y, hy⟩ ∈ (groupHomology.shortComplexH1 A).moduleCatToCyc... | null | false |
instCStarAlgebraProd._proof_2 | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {A : Type u_2} {B : Type u_1} [inst : CStarAlgebra A] [inst_1 : CStarAlgebra B], CStarRing (A × B) | null | false |
Matroid.indep_iff_forall_closure_sdiff_ne | Mathlib.Combinatorics.Matroid.Closure | ∀ {α : Type u_2} {M : Matroid α} {I : Set α}, M.Indep I ↔ ∀ ⦃e : α⦄, e ∈ I → M.closure (I \ {e}) ≠ M.closure I | null | true |
CategoryTheory.Functor.OneHypercoverDenseData.essSurj.presheafMap_comp | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | ∀ {C₀ : Type u₀} {C : Type u} [inst : CategoryTheory.Category.{v₀, u₀} C₀] [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor C₀ C} {J₀ : CategoryTheory.GrothendieckTopology C₀}
{J : CategoryTheory.GrothendieckTopology C} {A : Type u'} [inst_2 : CategoryTheory.Category.{v', u'} A]
[inst_3 : C... | null | true |
Lean.Meta.Grind.AC.EqCnstrProof.erase0_rhs.sizeOf_spec | Lean.Meta.Tactic.Grind.AC.Types | ∀ (c : Lean.Meta.Grind.AC.EqCnstr), sizeOf (Lean.Meta.Grind.AC.EqCnstrProof.erase0_rhs c) = 1 + sizeOf c | null | true |
CategoryTheory.Limits.CategoricalPullback.instCategory._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u_4} {B : Type u_2} {C : Type u_6} [inst : CategoryTheory.Category.{u_3, u_4} A]
[inst_1 : CategoryTheory.Category.{u_1, u_2} B] [inst_2 : CategoryTheory.Category.{u_5, u_6} C]
{F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B} (x : CategoryTheory.Limits.CategoricalPullback F G),
Catego... | null | false |
_private.Mathlib.Order.Defs.Unbundled.0.«term_≺_» | Mathlib.Order.Defs.Unbundled | Lean.TrailingParserDescr | Local notation for an arbitrary binary relation `r`. | true |
_private.Mathlib.Topology.Irreducible.0.isIrreducible_iff_sUnion_isClosed._simp_1_12 | Mathlib.Topology.Irreducible | ∀ {α : Type u} {s t : Set α}, (¬Disjoint s t) = (s ∩ t).Nonempty | null | false |
CategoryTheory.Limits.BinaryBicone.ofColimitCocone_inl | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C}
{t : CategoryTheory.Limits.Cocone (CategoryTheory.Limits.pair X Y)} (ht : CategoryTheory.Limits.IsColimit t),
(CategoryTheory.Limits.BinaryBicone.ofColimitCocone ht).inl = t.ι.app { as := CategoryTheory.Limits... | null | true |
TopologicalSpace.isClosed_range_singleton | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} [inst : TopologicalSpace α] [T2Space α] {t : TopologicalSpace (Set α)},
IsOpen {∅} → (∀ {U : Set α}, IsOpen U → IsOpen {s | (s ∩ U).Nonempty}) → IsClosed (Set.range fun x => {x}) | Auxiliary lemma showing that singleton sets form a closed set. It takes the required topological
properties as arguments, so that it applies to both the Vietoris topology and the Hausdorff
uniformity. | true |
MeasureTheory.Measure.InnerRegularWRT.of_imp | Mathlib.MeasureTheory.Measure.Regular | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {p q : Set α → Prop},
(∀ (s : Set α), q s → p s) → μ.InnerRegularWRT p q | null | true |
Subgroup.isComplement'_bot_top | Mathlib.GroupTheory.Complement | ∀ {G : Type u_1} [inst : Group G], ⊥.IsComplement' ⊤ | null | true |
Lean.getPPAnalyzeTrustSubst | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | Lean.Options → Bool | null | true |
Algebraic.countable | Mathlib.Algebra.AlgebraicCard | ∀ (R : Type u) (A : Type v) [inst : CommRing R] [IsDomain R] [inst_2 : CommRing A] [IsDomain A] [inst_4 : Algebra R A]
[Module.IsTorsionFree R A] [Countable R], {x | IsAlgebraic R x}.Countable | null | true |
_private.Lean.Widget.Commands.0.Lean.Widget.elabShowPanelWidgetsCmd._sparseCasesOn_4 | Lean.Widget.Commands | {motive : Lean.AttributeKind → Sort u} →
(t : Lean.AttributeKind) → motive Lean.AttributeKind.local → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
btw_rfl_right | Mathlib.Order.Circular | ∀ {α : Type u_1} [inst : CircularOrder α] {a b : α}, btw a b b | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastCpopTreeTarget.len | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Cpop | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} → {w : ℕ} → Std.Tactic.BVDecide.BVExpr.bitblast.blastCpopTreeTarget aig w → ℕ | null | true |
CategoryTheory.op_mono_iff._simp_1 | Mathlib.CategoryTheory.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : Y ⟶ X),
CategoryTheory.Mono f.op = CategoryTheory.Epi f | null | false |
ProbabilityTheory.parallelProd_posterior_comp_copy_comp | Mathlib.Probability.Kernel.Posterior | ∀ {Ω : Type u_1} {𝓧 : Type u_2} {mΩ : MeasurableSpace Ω} {m𝓧 : MeasurableSpace 𝓧} {κ : ProbabilityTheory.Kernel Ω 𝓧}
{μ : MeasureTheory.Measure Ω} [inst : MeasureTheory.IsFiniteMeasure μ] [inst_1 : ProbabilityTheory.IsFiniteKernel κ]
[inst_2 : StandardBorelSpace Ω] [inst_3 : Nonempty Ω],
((μ.bind ⇑κ).bind ⇑(P... | The main property of the posterior, as equality of the following diagrams:
```
-- id -- κ
μ -- κ -| = μ -|
-- κ†μ -- id
``` | true |
CochainComplex.shiftShortComplexFunctor'._proof_1 | Mathlib.Algebra.Homology.HomotopyCategory.ShiftSequence | IsRightCancelAdd ℤ | null | false |
_private.Batteries.Data.AssocList.0.List.toAssocList.match_1.eq_1 | Batteries.Data.AssocList | ∀ {α : Type u_2} {β : Type u_1} (motive : List (α × β) → Sort u_3) (h_1 : Unit → motive [])
(h_2 : (a : α) → (b : β) → (es : List (α × β)) → motive ((a, b) :: es)),
(match [] with
| [] => h_1 ()
| (a, b) :: es => h_2 a b es) =
h_1 () | null | true |
_private.Lean.Meta.Tactic.Grind.VarRename.0.Lean.Meta.Grind.collectMapVars.match_1 | Lean.Meta.Tactic.Grind.VarRename | {α : Type u_1} →
{Expr : Type u_2} →
(motive : α × Expr → Sort u_3) → (x : α × Expr) → ((a : α) → (snd : Expr) → motive (a, snd)) → motive x | null | false |
Lean.Elab.Tactic.Omega.State.recOn | Lean.Elab.Tactic.Omega.OmegaM | {motive : Lean.Elab.Tactic.Omega.State → Sort u} →
(t : Lean.Elab.Tactic.Omega.State) → ((atoms : Std.HashMap Lean.Expr ℕ) → motive { atoms := atoms }) → motive t | null | false |
IsClosed.rec | Mathlib.Topology.Defs.Basic | {X : Type u} →
[inst : TopologicalSpace X] →
{s : Set X} →
{motive : IsClosed s → Sort u_1} → ((isOpen_compl : IsOpen sᶜ) → motive ⋯) → (t : IsClosed s) → motive t | null | false |
Int.shiftLeft_add | Init.Data.Int.Bitwise.Lemmas | ∀ (a : ℤ) (b c : ℕ), a <<< (b + c) = a <<< b <<< c | null | true |
isMinOn_univ_of_anti_mono | Mathlib.Order.Filter.Extr | ∀ {α : Type u} {β : Type u_1} [inst : LinearOrder α] [inst_1 : Preorder β] {b : α} {f : α → β},
AntitoneOn f (Set.Iic b) → MonotoneOn f (Set.Ici b) → IsMinOn f Set.univ b | If `f` is antitone on `Iic b` and monotone on `Ici b`, then the minimum of `f` is attained
at `b`. | true |
TopCat.range_pullback_map | Mathlib.Topology.Category.TopCat.Limits.Pullbacks | ∀ {W X Y Z S T : TopCat} (f₁ : W ⟶ S) (f₂ : X ⟶ S) (g₁ : Y ⟶ T) (g₂ : Z ⟶ T) (i₁ : W ⟶ Y) (i₂ : X ⟶ Z) (i₃ : S ⟶ T)
[H₃ : CategoryTheory.Mono i₃]
(eq₁ : CategoryTheory.CategoryStruct.comp f₁ i₃ = CategoryTheory.CategoryStruct.comp i₁ g₁)
(eq₂ : CategoryTheory.CategoryStruct.comp f₂ i₃ = CategoryTheory.CategoryStr... | If the map `S ⟶ T` is mono, then there is a description of the image of `W ×ₛ X ⟶ Y ×ₜ Z`. | true |
_private.Mathlib.Computability.TuringMachine.Config.0.Turing.ToPartrec.Code.eval.match_1.eq_7 | Mathlib.Computability.TuringMachine.Config | ∀ (motive : Turing.ToPartrec.Code → Sort u_1) (f : Turing.ToPartrec.Code)
(h_1 : Unit → motive Turing.ToPartrec.Code.zero') (h_2 : Unit → motive Turing.ToPartrec.Code.succ)
(h_3 : Unit → motive Turing.ToPartrec.Code.tail) (h_4 : (f fs : Turing.ToPartrec.Code) → motive (f.cons fs))
(h_5 : (f g : Turing.ToPartrec.C... | null | true |
CategoryTheory.Lax.OplaxTrans.vComp_naturality_naturality | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G H : CategoryTheory.LaxFunctor B C} (η : CategoryTheory.Lax.OplaxTrans F G)
(θ : CategoryTheory.Lax.OplaxTrans G H) {a b : B} {f g : a ⟶ b} (β : f ⟶ g),
CategoryTheory.CategoryStruct.comp (CategoryTheory.... | null | true |
_private.Mathlib.RingTheory.Ideal.AssociatedPrime.Localization.0.Module.associatedPrimes.comap_mem_associatedPrimes_of_mem_associatedPrimes_of_isLocalizedModule_of_fg._simp_1_4 | Mathlib.RingTheory.Ideal.AssociatedPrime.Localization | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Submodule R M}
{x : M} {r : R}, (r ∈ N.colon {x}) = (r • x ∈ N) | null | false |
_aux_Mathlib_Topology_Algebra_ContinuousAffineMap___unexpand_ContinuousAffineMap_1 | Mathlib.Topology.Algebra.ContinuousAffineMap | Lean.PrettyPrinter.Unexpander | null | false |
SSet.Subcomplex.MulticoequalizerDiagram.isColimit'._proof_2 | Mathlib.AlgebraicTopology.SimplicialSet.SubcomplexColimits | ∀ {X : SSet} {A : X.Subcomplex} {ι : Type u_2} {U : ι → X.Subcomplex} {V : ι → ι → X.Subcomplex}
(h : A.MulticoequalizerDiagram U V) (x x_1 : ι),
CategoryTheory.CategoryStruct.comp (SSet.Subcomplex.toSSetFunctor.mapIso (CategoryTheory.eqToIso ⋯)).hom
(((CompleteLattice.MulticoequalizerDiagram.multispanIndex h... | null | false |
_private.Mathlib.LinearAlgebra.Matrix.PosDef.0.Matrix.posSemidef_diagonal_iff.match_1_1 | Mathlib.LinearAlgebra.Matrix.PosDef | ∀ {n : Type u_1} {R : Type u_2} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R] [inst_3 : DecidableEq n]
{d : n → R} (motive : (Matrix.diagonal d).PosSemidef → Prop) (x : (Matrix.diagonal d).PosSemidef),
(∀ (left : (Matrix.diagonal d).IsHermitian)
(hP : ∀ (x : n →₀ R), 0 ≤ x.sum fun i xi => x.... | null | false |
Plausible.retry | Plausible.Testable | {p : Prop} → Plausible.Gen (Plausible.TestResult p) → ℕ → Plausible.Gen (Plausible.TestResult p) | Execute `cmd` and repeat every time the result is `gaveUp` (at most `n` times). | true |
BitVec.slt_eq_sle_and_ne | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x y : BitVec w}, x.slt y = (x.sle y && x != y) | null | true |
AlgebraicGeometry.PresheafedSpace.Hom.ext._proof_1 | Mathlib.Geometry.RingedSpace.PresheafedSpace | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {X Y : AlgebraicGeometry.PresheafedSpace C}
(α β : X.Hom Y), α.base = β.base → (TopologicalSpace.Opens.map α.base).op = (TopologicalSpace.Opens.map β.base).op | null | false |
List.zipWithLeft'TR.go._sunfold | Batteries.Data.List.Basic | {α : Type u_1} → {β : Type u_2} → {γ : Type u_3} → (α → Option β → γ) → List α → List β → Array γ → List γ × List β | null | false |
Homeomorph.instGroup._proof_5 | Mathlib.Topology.Homeomorph.Defs | ∀ {X : Type u_1} [inst : TopologicalSpace X] (n : ℕ) (a : X ≃ₜ X),
zpowRec npowRec (↑n.succ) a = zpowRec npowRec (↑n) a * a | null | false |
CategoryTheory.Limits.Cocone.precomposeEquivalence._proof_10 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] {C : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} C] {F G : CategoryTheory.Functor J C} (α : F ≅ G)
(X : CategoryTheory.Limits.Cocone F),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.NatIso.ofComponents'
(fun s =>
... | null | false |
_private.Mathlib.RingTheory.HahnSeries.Multiplication.0.HahnSeries.coeff_mul_single_add._simp_1_4 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) | null | false |
CategoryTheory.Localization.Construction.LocQuiver.mk.injEq | Mathlib.CategoryTheory.Localization.Construction | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] {W : CategoryTheory.MorphismProperty C} (obj obj_1 : C),
({ obj := obj } = { obj := obj_1 }) = (obj = obj_1) | null | true |
WeierstrassCurve.natDegree_preΨ | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Degree | ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R) {n : ℤ},
↑n ≠ 0 → (W.preΨ n).natDegree = (n.natAbs ^ 2 - if Even n then 4 else 1) / 2 | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Trails.0.SimpleGraph.Walk.IsEulerian.card_filter_odd_degree._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Trails | ∀ {n : ℕ}, Odd n = ¬Even n | null | false |
Group.isNilpotent_of_product_of_sylow_group | Mathlib.GroupTheory.Nilpotent | ∀ {G : Type u_1} [hG : Group G] [Finite G] (e : ((p : ↥(Nat.card G).primeFactors) → (P : Sylow (↑p) G) → ↥↑P) ≃* G),
Group.IsNilpotent G | If a finite group is the direct product of its Sylow groups, it is nilpotent | true |
_private.Mathlib.MeasureTheory.Measure.HasOuterApproxClosed.0.HasOuterApproxClosed.measure_le_lintegral._simp_1_1 | Mathlib.MeasureTheory.Measure.HasOuterApproxClosed | ∀ {α : Type u_1} {m : MeasurableSpace α}, MeasurableSet Set.univ = True | null | false |
_private.Mathlib.CategoryTheory.Abelian.Projective.Dimension.0.CategoryTheory.Retract.projectiveDimension_le._simp_1_1 | Mathlib.CategoryTheory.Abelian.Projective.Dimension | ∀ {α : Type u} [inst : Preorder α] [inst_1 : OrderTop α] {a : α}, (⊤ < a) = False | null | false |
_private.Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors.0.MvPowerSeries.mem_nonZeroDivisorsRight_of_constantCoeff._simp_1_2 | Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors | ∀ {α : Type u_1} [inst : LE α] [inst_1 : Zero α] [IsBotZeroClass α] {a : α}, (0 ≤ a) = True | null | false |
Finset.apply_inf_eq_inf_comp_of_linearOrder | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_2} {β : Type u_3} {ι : Type u_5} [inst : LinearOrder α] [inst_1 : OrderTop α] {s : Finset ι} {f : ι → α}
[inst_2 : SemilatticeInf β] [inst_3 : OrderTop β] (g : α → β), Monotone g → g ⊤ = ⊤ → g (s.inf f) = s.inf (g ∘ f) | null | true |
LeftCancelMonoid.groupOfFinite | Mathlib.GroupTheory.OrderOfElement | {G : Type u_1} → [LeftCancelMonoid G] → [Finite G] → Group G | Every finite left cancellative monoid is a group. | true |
CategoryTheory.Limits.isIsoZeroEquiv | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
(X Y : C) →
CategoryTheory.IsIso 0 ≃ CategoryTheory.CategoryStruct.id X = 0 ∧ CategoryTheory.CategoryStruct.id Y = 0 | A zero morphism `0 : X ⟶ Y` is an isomorphism if and only if
the identities on both `X` and `Y` are zero.
| true |
Lean.Lsp.TextDocumentPositionParams.rec | Lean.Data.Lsp.Basic | {motive : Lean.Lsp.TextDocumentPositionParams → Sort u} →
((textDocument : Lean.Lsp.TextDocumentIdentifier) →
(position : Lean.Lsp.Position) → motive { textDocument := textDocument, position := position }) →
(t : Lean.Lsp.TextDocumentPositionParams) → motive t | null | false |
_private.Mathlib.ModelTheory.Encoding.0.FirstOrder.Language.Term.listEncode.match_1.splitter | Mathlib.ModelTheory.Encoding | {L : FirstOrder.Language} →
{α : Type u_3} →
(motive : L.Term α → Sort u_4) →
(x : L.Term α) →
((i : α) → motive (FirstOrder.Language.var i)) →
((l : ℕ) → (f : L.Functions l) → (ts : Fin l → L.Term α) → motive (FirstOrder.Language.func f ts)) → motive x | null | true |
_private.Lean.Elab.Tactic.Monotonicity.0.Lean.Meta.Monotonicity.initFn._@.Lean.Elab.Tactic.Monotonicity.1250514167._hygCtx._hyg.2 | Lean.Elab.Tactic.Monotonicity | IO Unit | Registers a monotonicity theorem for `partial_fixpoint`.
Monotonicity theorems should have `Lean.Order.monotone ...` as a conclusion. They are used in the
`monotonicity` tactic (scoped in the `Lean.Order` namespace) to automatically prove monotonicity
for functions defined using `partial_fixpoint`.
| false |
tprod_mulIndicator_of_mem_union_disjoint | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : CommMonoid α] [inst_1 : TopologicalSpace α] (s : γ → Set β)
(f : β → α), Pairwise (Function.onFun Disjoint s) → ∀ i ∈ ⋃ d, s d, ∏' (d : γ), (s d).mulIndicator f i = f i | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Traversal.0.SimpleGraph.Walk.getVert_comp_val_eq_get_support._proof_1_3 | Mathlib.Combinatorics.SimpleGraph.Walk.Traversal | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V} (p : G.Walk u v), p.getVert ∘ Fin.val = p.support.get | null | false |
CategoryTheory.Limits.binaryCofanZeroLeftIsColimit | Mathlib.CategoryTheory.Limits.Constructions.ZeroObjects | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroObject C] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] →
(X : C) → CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.binaryCofanZeroLeft X) | The colimit cocone for the coproduct with a zero object is colimiting. | true |
QuotientAddGroup.equivIocMod._proof_4 | Mathlib.Algebra.Order.ToIntervalMod | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [inst_2 : IsOrderedAddMonoid α] [hα : Archimedean α]
{p : α} (hp : 0 < p) (a : α) (b : ↑(Set.Ioc a (a + p))), ⟨⋯.lift ↑↑b, ⋯⟩ = b | null | false |
CategoryTheory.PreOneHypercover.instIsIsoH₁Hom | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E F : CategoryTheory.PreOneHypercover S} (e : E ≅ F)
{i j : E.I₀} (k : E.I₁ i j), CategoryTheory.IsIso (e.hom.h₁ k) | null | true |
Int.emod_abs | Mathlib.Algebra.Order.Group.Unbundled.Int | ∀ (a b : ℤ), a % |b| = a % b | null | true |
ValuedCSP.Term.noConfusionType | Mathlib.Combinatorics.Optimization.ValuedCSP | Sort u →
{D : Type u_1} →
{C : Type u_2} →
[inst : AddCommMonoid C] →
[inst_1 : PartialOrder C] →
[inst_2 : IsOrderedAddMonoid C] →
{Γ : ValuedCSP D C} →
{ι : Type u_3} →
Γ.Term ι →
{D' : Type u_1} →
{C' : Type... | null | false |
_private.Mathlib.RingTheory.Localization.Ideal.0.IsLocalization.map_inf._simp_1_2 | Mathlib.RingTheory.Localization.Ideal | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∃ x, p x) = ∃ a b, p (a, b) | null | false |
Lean.Meta.Simp.Diagnostics.thmsWithBadKeys | Lean.Meta.Tactic.Simp.Types | Lean.Meta.Simp.Diagnostics → Lean.PArray Lean.Meta.SimpTheorem | When using `Simp.Config.index := false`, and `set_option diagnostics true`,
for every theorem used by `simp`, we check whether the theorem would be
also applied if `index := true`, and we store it here if it would not have
been tried.
| true |
RootPairing.pairingIn_lt_zero_iff | Mathlib.LinearAlgebra.RootSystem.Finite.CanonicalBilinear | ∀ {ι : 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) (S : Type u_5)
[inst_5 : CommRing S] [inst_6 : LinearOrder S] [IsStrictOrderedRing S] [inst_8 : Algebra S R] [Fa... | null | true |
ComputablePred.computable_iff | Mathlib.Computability.RE | ∀ {α : Type u_1} [inst : Primcodable α] {p : α → Prop}, ComputablePred p ↔ ∃ f, Computable f ∧ p = fun a => f a = true | null | true |
ContinuousLinearMap.inl | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.PiProd | (R : Type u_1) →
[inst : Semiring R] →
(M₁ : Type u_2) →
[inst_1 : TopologicalSpace M₁] →
[inst_2 : AddCommMonoid M₁] →
[inst_3 : Module R M₁] →
(M₂ : Type u_3) →
[inst_4 : TopologicalSpace M₂] → [inst_5 : AddCommMonoid M₂] → [inst_6 : Module R M₂] → M₁ →L[R] M₁ ×... | The left injection into a product is a continuous linear map. | true |
EReal.neBotTopHomeomorphReal._proof_2 | Mathlib.Topology.Instances.EReal.Lemmas | Continuous fun x => ⟨↑x, ⋯⟩ | null | false |
HasDerivWithinAt.finsetProd | Mathlib.Analysis.Calculus.Deriv.Mul | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {s : Set 𝕜} {ι : Type u_2} [inst_1 : DecidableEq ι]
{𝔸' : Type u_3} [inst_2 : NormedCommRing 𝔸'] [inst_3 : NormedAlgebra 𝕜 𝔸'] {u : Finset ι} {f : ι → 𝕜 → 𝔸'}
{f' : ι → 𝔸'},
(∀ i ∈ u, HasDerivWithinAt (f i) (f' i) s x) →
HasDerivWithinAt (∏ ... | null | true |
FiniteIndexNormalSubgroup.comap_id | Mathlib.GroupTheory.FiniteIndexNormalSubgroup | ∀ {G : Type u_1} [inst : Group G] (K : FiniteIndexNormalSubgroup G),
FiniteIndexNormalSubgroup.comap (MonoidHom.id G) K = K | null | true |
_private.Init.Data.Iterators.Lemmas.Basic.0.Std.Iter.inductSteps._proof_2 | Init.Data.Iterators.Lemmas.Basic | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] [inst_1 : Std.Iterators.Finite α Id] (it : Std.Iter β)
{it' : Std.Iter β} {x : β},
it.IsPlausibleStep (Std.IterStep.yield it' x) →
(invImage (fun x => x.finitelyManySteps) Std.IterM.TerminationMeasures.instWellFoundedRelationFinite).1 it' it | null | false |
Complex.instTietzeExtension | Mathlib.Analysis.Complex.Tietze | TietzeExtension ℂ | null | true |
IsAddRightRegular.nsmul | Mathlib.Algebra.Regular.Basic | ∀ {R : Type u_1} [inst : AddMonoid R] {a : R} (n : ℕ), IsAddRightRegular a → IsAddRightRegular (n • a) | null | true |
CompletePartialOrder.ctorIdx | Mathlib.Order.CompletePartialOrder | {α : Type u_4} → CompletePartialOrder α → ℕ | null | false |
Std.ExtDTreeMap.mergeWith._proof_1 | Std.Data.ExtDTreeMap.Basic | ∀ {α : Type u_1} {β : α → Type u_2} {cmp : α → α → Ordering} [Std.TransCmp cmp] [inst : Std.LawfulEqCmp cmp]
(mergeFn : (a : α) → β a → β a → β a) (x x_1 x_2 x_3 : Std.DTreeMap α β cmp),
x.Equiv x_2 →
x_1.Equiv x_3 →
Std.ExtDTreeMap.mk (Std.DTreeMap.mergeWith mergeFn x x_1) =
Std.ExtDTreeMap.mk (S... | null | false |
SimpleGraph.Embedding.preimage_edgeSet | Mathlib.Combinatorics.SimpleGraph.Maps | ∀ {V : Type u_1} {W : Type u_2} {G : SimpleGraph V} {G' : SimpleGraph W} (f : G ↪g G'),
Sym2.map ⇑f ⁻¹' G'.edgeSet = G.edgeSet | null | true |
AlgebraicGeometry.QuasiSeparated | Mathlib.AlgebraicGeometry.Morphisms.QuasiSeparated | {X Y : AlgebraicGeometry.Scheme} → (X ⟶ Y) → Prop | A morphism is `QuasiSeparated` if diagonal map is quasi-compact. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.