name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
List.bagInter.match_1.congr_eq_3 | Mathlib.Data.List.Lattice | ∀ {α : Type u_1} (motive : List α → List α → Sort u_2) (x x_1 : List α) (h_1 : (x : List α) → motive [] x)
(h_2 : (x : List α) → motive x []) (h_3 : (a : α) → (l₁ l₂ : List α) → motive (a :: l₁) l₂) (a : α) (l₁ l₂ : List α),
x = a :: l₁ →
x_1 = l₂ →
(l₂ = [] → False) →
(match x, x_1 with
... | null | true |
rothNumberNat_le_ruzsaSzemerediNumberNat' | Mathlib.Combinatorics.Extremal.RuzsaSzemeredi | ∀ (n : ℕ), (↑n / 3 - 2) * ↑(rothNumberNat ((n - 3) / 6)) ≤ ↑(ruzsaSzemerediNumberNat n) | Lower bound on the **Ruzsa-Szemerédi problem** in terms of 3AP-free sets.
If there exists a 3AP-free subset of `[1, ..., (n - 3) / 6]` of size `m`, then there exists a graph
with `n` vertices and `(n / 3 - 2) * m` edges such that each edge belongs to exactly one triangle.
| true |
_private.Mathlib.Analysis.SpecialFunctions.Gaussian.GaussianIntegral.0.integral_gaussian_complex._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Gaussian.GaussianIntegral | Complex.ofReal = ⇑(algebraMap ℝ ℂ) | null | false |
PointedCone.IsFaceOf.trans | Mathlib.Geometry.Convex.Cone.Face.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] {C F₁ F₂ : PointedCone R M},
F₂.IsFaceOf F₁ → F₁.IsFaceOf C → F₂.IsFaceOf C | The face of a face of a cone is also a face of the cone. | true |
mem_subalgebraOfSubring._simp_1 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u_1} [inst : Ring R] {x : R} {S : Subring R}, (x ∈ subalgebraOfSubring S) = (x ∈ S) | null | false |
CategoryTheory.Filtration.ι_app | Mathlib.CategoryTheory.Filtration.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} {I : Type u_1}
[inst_1 : CategoryTheory.Category.{u_2, u_1} I] (F : CategoryTheory.Filtration X I) (i : I),
F.ι.app i = (F.toMonoOver.obj i).obj.hom | null | true |
_private.Lean.Elab.DocString.0.Lean.Doc.elabBlock.withSpace | Lean.Elab.DocString | String → String | null | true |
Setoid.instPartialOrder | Mathlib.Order.Setoid.Basic | {α : Type u_1} → PartialOrder (Setoid α) | null | true |
AlgHom.toLieHom_apply | Mathlib.Algebra.Lie.OfAssociative | ∀ {A : Type v} [inst : Ring A] {R : Type u} [inst_1 : CommRing R] [inst_2 : Algebra R A] {B : Type w} [inst_3 : Ring B]
[inst_4 : Algebra R B] (f : A →ₐ[R] B) (x : A), f.toLieHom x = f x | null | true |
_private.Lean.Elab.Do.Legacy.0.Lean.Elab.Term.extractBind.match_4 | Lean.Elab.Do.Legacy | (motive : Option Lean.Expr → Sort u_1) →
(expectedType? : Option Lean.Expr) →
((expectedType : Lean.Expr) → motive (some expectedType)) →
((x : Option Lean.Expr) → motive x) → motive expectedType? | null | false |
MeasureTheory.measureReal_add_sdiff._auto_1 | Mathlib.MeasureTheory.Measure.Real | Lean.Syntax | null | false |
MeasureTheory.IsStoppingTime | Mathlib.Probability.Process.Stopping | {Ω : Type u_1} →
{ι : Type u_3} → {m : MeasurableSpace Ω} → [inst : Preorder ι] → MeasureTheory.Filtration ι m → (Ω → WithTop ι) → Prop | A stopping time with respect to some filtration `f` is a function
`τ` such that for all `i`, the preimage of `{j | j ≤ i}` along `τ` is measurable
with respect to `f i`.
Intuitively, the stopping time `τ` describes some stopping rule such that at time
`i`, we may determine it with the information we have at time `i`. | true |
Derivation.map_smul_of_tower | Mathlib.RingTheory.Derivation.Basic | ∀ {R : Type u_1} {A : Type u_2} {M : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring A]
[inst_2 : AddCommMonoid M] [inst_3 : Algebra R A] [inst_4 : Module A M] [inst_5 : Module R M] {S : Type u_5}
[inst_6 : SMul S A] [inst_7 : SMul S M] [LinearMap.CompatibleSMul A M S R] (D : Derivation R A M) (r : S) (a :... | null | true |
List.Perm.trans | Init.Data.List.Basic | ∀ {α : Type u} {l₁ l₂ l₃ : List α}, l₁.Perm l₂ → l₂.Perm l₃ → l₁.Perm l₃ | Permutation is transitive: `l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃`.
| true |
_private.Mathlib.Analysis.SpecialFunctions.Complex.Circle.0.Circle.exp_inj._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Complex.Circle | ∀ {G : Type u_1} [inst : AddCommGroup G] {p a b : G}, (a ≡ b [PMOD p]) = ∃ m, b - a = m • p | null | false |
LaurentPolynomial.isLocalization | Mathlib.Algebra.Polynomial.Laurent | ∀ {R : Type u_1} [inst : CommSemiring R], IsLocalization.Away Polynomial.X (LaurentPolynomial R) | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Basic.0.SimpleGraph.adj_incidenceSet_inter._simp_1_3 | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | null | false |
Quaternion.instGroupWithZero._proof_7 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} [inst : Field R], Nontrivial (QuaternionAlgebra R (-1) 0 (-1)) | null | false |
SimpleGraph.diam_anti_of_ediam_ne_top | Mathlib.Combinatorics.SimpleGraph.Diam | ∀ {α : Type u_1} {G G' : SimpleGraph α}, G ≤ G' → G.ediam ≠ ⊤ → G'.diam ≤ G.diam | null | true |
Lean.Order.instMonadTailST | Init.Internal.Order.MonadTail | {σ : Type} → Lean.Order.MonadTail (ST σ) | null | true |
_private.Lean.Parser.Term.Basic.0.Lean.Parser.Term.initFn._@.Lean.Parser.Term.Basic.2382944618._hygCtx._hyg.2 | Lean.Parser.Term.Basic | IO Unit | null | false |
Std.HashMap.Raw.emptyWithCapacity | Std.Data.HashMap.Raw | {α : Type u} → {β : Type v} → optParam ℕ 8 → Std.HashMap.Raw α β | Creates a new empty hash map. The optional parameter `capacity` can be supplied to presize the
map so that it can hold the given number of mappings without reallocating. It is also possible to
use the empty collection notations `∅` and `{}` to create an empty hash map with the default
capacity.
| true |
SheafOfModules.Presentation.IsFinite.casesOn | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{R : CategoryTheory.Sheaf J RingCat} →
[inst_1 : CategoryTheory.HasWeakSheafify J AddCommGrpCat] →
[inst_2 : J.WEqualsLocallyBijective AddCommGrpCat] →
{M : SheafOfModule... | null | false |
Lean.Core.Context.Cold.quotContext | Lean.CoreM | Lean.Core.Context.Cold → Lean.Name | null | true |
Lean.Elab.Term.Do.ToTerm.Kind.nestedSBC | Lean.Elab.Do.Legacy | Lean.Elab.Term.Do.ToTerm.Kind | null | true |
_private.Mathlib.Tactic.GRewrite.Core.0.Lean.MVarId.grewrite._sparseCasesOn_1 | Mathlib.Tactic.GRewrite.Core | {motive : ℕ → Sort u} → (t : ℕ) → ((n : ℕ) → motive n.succ) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.IsCycle.reverse._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} {u : V} {p : G.Walk u u}, p.reverse.support.tail.Nodup = p.support.tail.Nodup | null | false |
Ring.inverse_non_unit | Mathlib.Algebra.GroupWithZero.Units.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] (x : M₀), ¬IsUnit x → Ring.inverse x = 0 | By definition, if `x` is not invertible then `inverse x = 0`. | true |
HasDerivAt.nonpos_of_antitone | Mathlib.Analysis.Calculus.Deriv.Slope | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜]
[OrderTopology 𝕜] {g : 𝕜 → 𝕜} {g' : 𝕜}, HasDerivAt g g' x → Antitone g → g' ≤ 0 | If an antitone function has a derivative, then this derivative is nonpositive. | true |
Module.Basis.addSubgroupOfClosure._proof_1 | Mathlib.LinearAlgebra.Basis.Submodule | ∀ {M : Type u_1} {R : Type u_3} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (A : AddSubgroup M)
{ι : Type u_2} (b : Module.Basis ι R M),
A = AddSubgroup.closure (Set.range ⇑b) → Submodule.span ℤ (Set.range ⇑b) = AddSubgroup.toIntSubmodule A | null | false |
CategoryTheory.Limits.PushoutCocone.ext | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y Z : C} →
{f : X ⟶ Y} →
{g : X ⟶ Z} →
{s t : CategoryTheory.Limits.PushoutCocone f g} →
(i : s.pt ≅ t.pt) →
autoParam (CategoryTheory.CategoryStruct.comp s.inl i.hom = t.inl)
Category... | To construct an isomorphism of pushout cocones, it suffices to construct an isomorphism
of the cocone points and check it commutes with `inl` and `inr`. | true |
ProbabilityTheory.Kernel.condKernelReal.eq_1 | Mathlib.Probability.Kernel.Disintegration.StandardBorel | ∀ {α : Type u_1} {γ : Type u_3} {mα : MeasurableSpace α} {mγ : MeasurableSpace γ}
[inst : MeasurableSpace.CountablyGenerated γ] (κ : ProbabilityTheory.Kernel α (γ × ℝ))
[inst_1 : ProbabilityTheory.IsFiniteKernel κ],
κ.condKernelReal = ProbabilityTheory.IsCondKernelCDF.toKernel κ.condKernelCDF ⋯ | null | true |
Nonempty.some | Mathlib.Basic.Nonempty | {α : Sort u_3} → Nonempty α → α | Using `Classical.choice`, extracts a term from a `Nonempty` type. | true |
_private.Mathlib.Order.Filter.AtTopBot.Archimedean.0.Filter.map_add_atTop_eq._simp_1_1 | Mathlib.Order.Filter.AtTopBot.Archimedean | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α] [AddRightMono α] {a b c : α}, (a ≤ c - b) = (a + b ≤ c) | null | false |
Lagrange.eval_basis_of_ne | Mathlib.LinearAlgebra.Lagrange | ∀ {F : Type u_1} [inst : Field F] {ι : Type u_2} [inst_1 : DecidableEq ι] {s : Finset ι} {v : ι → F} {i j : ι},
i ≠ j → j ∈ s → Polynomial.eval (v j) (Lagrange.basis s v i) = 0 | null | true |
Lean.registerOption | Lean.Data.Options | Lean.Name → Lean.OptionDecl → IO Unit | null | true |
TensorProduct.norm_map | Mathlib.Analysis.InnerProductSpace.TensorProduct | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} {H : Type u_5} [inst : RCLike 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E] [inst_3 : NormedAddCommGroup F]
[inst_4 : InnerProductSpace 𝕜 F] [inst_5 : NormedAddCommGroup G] [inst_6 : InnerProductSpace 𝕜 G]
[inst_7 : NormedAdd... | null | true |
Finsupp.sum_ite_eq | Mathlib.Algebra.BigOperators.Finsupp.Basic | ∀ {α : Type u_1} {M : Type u_8} {N : Type u_10} [inst : Zero M] [inst_1 : AddCommMonoid N] [inst_2 : DecidableEq α]
(f : α →₀ M) (a : α) (b : α → M → N),
(f.sum fun x v => if a = x then b x v else 0) = if a ∈ f.support then b a (f a) else 0 | null | true |
Lean.PersistentHashMap.mk.injEq | Lean.Data.PersistentHashMap | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] (root root_1 : Lean.PersistentHashMap.Node α β),
({ root := root } = { root := root_1 }) = (root = root_1) | null | true |
Lean.ExternEntry.inline.noConfusion | Lean.Compiler.ExternAttr | {P : Sort u} →
{backend : Lean.Name} →
{pattern : String} →
{backend' : Lean.Name} →
{pattern' : String} →
Lean.ExternEntry.inline backend pattern = Lean.ExternEntry.inline backend' pattern' →
(backend = backend' → pattern = pattern' → P) → P | null | false |
FirstOrder.Language.Term.inhabitedOfConstant | Mathlib.ModelTheory.Syntax | {L : FirstOrder.Language} → {α : Type u'} → [Inhabited L.Constants] → Inhabited (L.Term α) | null | true |
MeasureTheory.Lp.coeFn_tsum | Mathlib.MeasureTheory.Function.LpSpace.InfiniteSum | ∀ {X : Type u_1} {E : Type u_2} {x : MeasurableSpace X} {μ : MeasureTheory.Measure X} [inst : NormedAddCommGroup E]
{ι : Type u_3} [Countable ι] {p : ENNReal} [hp : Fact (1 ≤ p)] [CompleteSpace E] {f : ι → ↥(MeasureTheory.Lp E p μ)},
∑' (n : ι), ‖f n‖ₑ ≠ ⊤ → ↑↑(∑' (n : ι), f n) =ᵐ[μ] fun x_1 => ∑' (n : ι), ↑↑(f n) ... | null | true |
Mathlib.Tactic.Order.AtomicFact.le.sizeOf_spec | Mathlib.Tactic.Order.CollectFacts | ∀ (lhs rhs : ℕ) (proof : Lean.Expr),
sizeOf (Mathlib.Tactic.Order.AtomicFact.le lhs rhs proof) = 1 + sizeOf lhs + sizeOf rhs + sizeOf proof | null | true |
OrderDual.instSemigroup | Mathlib.Algebra.Order.Group.Synonym | {α : Type u_1} → [Semigroup α] → Semigroup αᵒᵈ | null | true |
EReal.instInv | Mathlib.Data.EReal.Inv | Inv EReal | null | true |
RegularSpace.inf | Mathlib.Topology.Separation.Regular | ∀ {X : Type u_3} {t₁ t₂ : TopologicalSpace X}, RegularSpace X → RegularSpace X → RegularSpace X | null | true |
FirstOrder.Language.IsOrdered.recOn | Mathlib.ModelTheory.Order | {L : FirstOrder.Language} →
{motive : L.IsOrdered → Sort u_1} →
(t : L.IsOrdered) → ((leSymb : L.Relations 2) → motive { leSymb := leSymb }) → motive t | null | false |
DomAddAct.mk_vadd_indicatorConstLp._proof_1 | Mathlib.MeasureTheory.Function.LpSpace.DomAct.Basic | ∀ {M : Type u_2} {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : VAdd M α]
[MeasureTheory.VAddInvariantMeasure M α μ] (c : M) {s : Set α},
MeasurableSet s → μ s ≠ ⊤ → μ ((fun x => c +ᵥ x) ⁻¹' s) ≠ ⊤ | null | false |
HasEnoughRootsOfUnity.finite_rootsOfUnity | Mathlib.RingTheory.RootsOfUnity.EnoughRootsOfUnity | ∀ (M : Type u_1) [inst : CommMonoid M] (n : ℕ) [NeZero n] [HasEnoughRootsOfUnity M n], Finite ↥(rootsOfUnity n M) | If `M` satisfies `HasEnoughRootsOfUnity`, then the group of `n`th roots of unity
in `M` is finite. | true |
_private.Mathlib.Order.Filter.Map.0.Filter.mem_comap_prodMk._simp_1_5 | Mathlib.Order.Filter.Map | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | null | false |
LinearMap.map_domRestrict | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_4} {M₂ : Type u_5} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {σ₂₁ : R₂ →+* R}
[inst_6 : RingHomSurjective σ₂₁] (p : Submodule R₂ M₂) (f : M₂ →ₛₗ[σ₂₁] M) (p' : Submodule ... | null | true |
MeasureTheory.VectorMeasure.instIsFiniteMeasureVariationMap | Mathlib.MeasureTheory.VectorMeasure.Variation.Basic | ∀ {X : Type u_1} {V : Type u_2} {mX : MeasurableSpace X} [inst : TopologicalSpace V] [inst_1 : ENormedAddCommMonoid V]
[inst_2 : T2Space V] {μ : MeasureTheory.VectorMeasure X V} {Y : Type u_3} [inst_3 : MeasurableSpace Y] {φ : X → Y}
[MeasureTheory.IsFiniteMeasure μ.variation], MeasureTheory.IsFiniteMeasure (μ.map ... | null | true |
Submodule.spanRank_finite_iff_fg._simp_1 | Mathlib.Algebra.Module.SpanRank | ∀ {R : Type u_1} {M : Type u} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {p : Submodule R M},
(p.spanRank < Cardinal.aleph0) = p.FG | null | false |
MvPolynomial.decomposition | Mathlib.RingTheory.MvPolynomial.Homogeneous | {σ : Type u_1} →
{R : Type u_3} → [inst : CommSemiring R] → DirectSum.Decomposition (MvPolynomial.homogeneousSubmodule σ R) | The decomposition of `MvPolynomial σ R` into homogeneous submodules. | true |
Lean.pp.safeShadowing | Lean.PrettyPrinter.Delaborator.Options | Lean.Option Bool | null | true |
_private.Mathlib.Tactic.Basify.Attr.0.Mathlib.Tactic.Basify.analyzeOp.match_5 | Mathlib.Tactic.Basify.Attr | (motive : Option (Lean.Expr × Lean.Expr × Lean.Expr) → Sort u_1) →
(x : Option (Lean.Expr × Lean.Expr × Lean.Expr)) →
((fst lhs rhs : Lean.Expr) → motive (some (fst, lhs, rhs))) →
((x : Option (Lean.Expr × Lean.Expr × Lean.Expr)) → motive x) → motive x | null | false |
CategoryTheory.Over.coprod._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.BinaryProducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasBinaryCoproducts C]
{A : C} {X Y : CategoryTheory.Over A} (k : X ⟶ Y) (f g : CategoryTheory.Over A) (k_1 : f ⟶ g),
CategoryTheory.CategoryStruct.comp (X.coprodObj.map k_1)
(CategoryTheory.Over.homMk
(Cate... | null | false |
CategoryTheory.Distributive.«_aux_Mathlib_CategoryTheory_Distributive_Monoidal___macroRules_CategoryTheory_Distributive_term∂R_1» | Mathlib.CategoryTheory.Distributive.Monoidal | Lean.Macro | null | false |
_private.Mathlib.MeasureTheory.Measure.LevyConvergence.0.MeasureTheory.isTightMeasureSet_of_tendsto_charFun._proof_1_6 | Mathlib.MeasureTheory.Measure.LevyConvergence | (3 + 1).AtLeastTwo | null | false |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.NormalizePattern.Context.mk.sizeOf_spec | Lean.Meta.Tactic.Grind.EMatchTheorem | ∀ (symPrios : Lean.Meta.Grind.SymbolPriorities) (minPrio : ℕ),
sizeOf { symPrios := symPrios, minPrio := minPrio } = 1 + sizeOf symPrios + sizeOf minPrio | null | true |
trichotomous_def | Mathlib.Order.Defs.Unbundled | ∀ {α : Sort u_1} {r : α → α → Prop}, Std.Trichotomous r ↔ ∀ ⦃a b : α⦄, ¬r a b → ¬r b a → a = b | null | true |
Lean.Kernel.Exception.unknownConstant.elim | Lean.Environment | {motive : Lean.Kernel.Exception → Sort u} →
(t : Lean.Kernel.Exception) →
t.ctorIdx = 0 →
((env : Lean.Kernel.Environment) → (name : Lean.Name) → motive (Lean.Kernel.Exception.unknownConstant env name)) →
motive t | null | false |
CategoryTheory.imageOpUnop | Mathlib.CategoryTheory.Abelian.Opposite | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Abelian C] →
{X Y : C} → (f : X ⟶ Y) → Opposite.unop (CategoryTheory.Limits.image f.op) ≅ CategoryTheory.Limits.image f | The image of `f.op` is the opposite of the image of `f`. | true |
UInt64.le_antisymm_iff | Init.Data.UInt.Lemmas | ∀ {a b : UInt64}, a = b ↔ a ≤ b ∧ b ≤ a | null | true |
GaloisCoinsertion.liftCompleteLattice | Mathlib.Order.GaloisConnection.Basic | {α : Type u_1} →
{β : Type u_2} →
{u : α → β} →
{l : β → α} → [inst : PartialOrder β] → [inst_1 : CompleteLattice α] → GaloisCoinsertion l u → CompleteLattice β | Lift all suprema and infima along a Galois coinsertion | true |
_private.Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Basic.0.exists_continuous_add_one_of_isCompact_nnreal._simp_1_2 | Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Basic | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : One α] [NeZero 1], (1 = 0) = False | null | false |
SimpleGraph.UnitDistEmbedding.mk | Mathlib.Combinatorics.SimpleGraph.UnitDistance.Basic | {V : Type u_1} →
{G : SimpleGraph V} →
{E : Type u_3} →
[inst : MetricSpace E] → (p : V ↪ E) → (∀ {u v : V}, G.Adj u v → dist (p u) (p v) = 1) → G.UnitDistEmbedding E | null | true |
isProperMap_iff_isCompact_preimage | Mathlib.Topology.Maps.Proper.CompactlyGenerated | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [T2Space Y]
[CompactlyCoherentSpace Y] {f : X → Y},
IsProperMap f ↔ Continuous f ∧ ∀ ⦃K : Set Y⦄, IsCompact K → IsCompact (f ⁻¹' K) | If `Y` is Hausdorff and compactly coherent, then proper maps `X → Y` are exactly
continuous maps such that the preimage of any compact set is compact. This is in particular true
if `Y` is Hausdorff and sequential or locally compact. | true |
LinearMap.instDistribMulActionDomMulActOfSMulCommClass._proof_2 | Mathlib.Algebra.Module.LinearMap.Basic | ∀ {R : Type u_1} {R' : Type u_2} {M : Type u_3} {M' : Type u_4} [inst : Semiring R] [inst_1 : Semiring R']
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M'] [inst_4 : Module R M] [inst_5 : Module R' M'] {σ₁₂ : R →+* R'}
{S' : Type u_5} [inst_6 : Monoid S'] [inst_7 : DistribMulAction S' M] [inst_8 : SMulCommCla... | null | false |
_private.Mathlib.Analysis.Normed.Group.Bounded.0.Bornology.IsBounded.exists_pos_norm_le'.match_1_1 | Mathlib.Analysis.Normed.Group.Bounded | ∀ {E : Type u_1} [inst : SeminormedGroup E] {s : Set E} (motive : (∃ C, ∀ x ∈ s, ‖x‖ ≤ C) → Prop)
(x : ∃ C, ∀ x ∈ s, ‖x‖ ≤ C), (∀ (R₀ : ℝ) (hR₀ : ∀ x ∈ s, ‖x‖ ≤ R₀), motive ⋯) → motive x | null | false |
LinearMap.BilinForm.SeparatingRight.toMatrix | Mathlib.LinearAlgebra.Matrix.BilinearForm | ∀ {R₂ : Type u_3} {M₂ : Type u_4} [inst : CommRing R₂] [inst_1 : AddCommGroup M₂] [inst_2 : Module R₂ M₂] {ι : Type u_6}
[inst_3 : DecidableEq ι] [inst_4 : Fintype ι] {B : LinearMap.BilinForm R₂ M₂},
LinearMap.SeparatingRight B → ∀ (b : Module.Basis ι R₂ M₂), ((LinearMap.BilinForm.toMatrix b) B).SeparatingRight | null | true |
NumberField.mixedEmbedding.convexBodySum_isBounded | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K] (B : ℝ),
Bornology.IsBounded (NumberField.mixedEmbedding.convexBodySum K B) | null | true |
Mathlib.Meta.Nat.UnifyZeroOrSuccResult.succ.noConfusion | Mathlib.Tactic.NormNum.BigOperators | {n : Q(ℕ)} →
{P : Sort u} →
{n' : Q(ℕ)} →
{pf : «$n» =Q «$n'».succ} →
{n'' : Q(ℕ)} →
{pf' : «$n» =Q «$n''».succ} →
Mathlib.Meta.Nat.UnifyZeroOrSuccResult.succ n' pf = Mathlib.Meta.Nat.UnifyZeroOrSuccResult.succ n'' pf' →
(n' = n'' → P) → P | null | false |
Filter.EventuallyEq.isTheta | Mathlib.Analysis.Asymptotics.Theta | ∀ {α : Type u_1} {E : Type u_3} [inst : Norm E] {l : Filter α} {f g : α → E}, f =ᶠ[l] g → f =Θ[l] g | null | true |
Std.DTreeMap.Const.minKey!_modify_eq_minKey! | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] [inst : Inhabited α] {k : α} {f : β → β}, (Std.DTreeMap.Const.modify t k f).minKey! = t.minKey! | null | true |
Algebra.IsUnramifiedAt.exists_hasStandardEtaleSurjectionOn | Mathlib.RingTheory.Unramified.LocalStructure | ∀ {R : Type u_1} {S : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (Q : Ideal S)
[inst_3 : Q.IsPrime] [Algebra.FiniteType R S] [Algebra.IsUnramifiedAt R Q], ∃ f ∉ Q, HasStandardEtaleSurjectionOn R f | null | true |
Std.Internal.Small.casesOn | Std.Data.Iterators.Lemmas.Equivalence.HetT | {α : Type v} →
{motive : Std.Internal.Small α → Sort u_1} →
(t : Std.Internal.Small α) → ((h : Nonempty (Std.Internal.ComputableSmall α)) → motive ⋯) → motive t | null | false |
_private.Mathlib.Data.Finset.Sigma.0.Finset.filter_sigma._simp_1_2 | Mathlib.Data.Finset.Sigma | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | null | false |
_private.Mathlib.MeasureTheory.Measure.Restrict.0.MeasureTheory.Measure.restrictₗ._simp_2 | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_1} (a b c : Set α), a ∩ (b \ c) = (a ∩ b) \ c | null | false |
AlgebraicGeometry.PresheafedSpace.instInhabited | Mathlib.Geometry.RingedSpace.PresheafedSpace | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] → [Inhabited C] → Inhabited (AlgebraicGeometry.PresheafedSpace C) | null | true |
IsAlgClosure.of_exists_root | Mathlib.FieldTheory.Isaacs | ∀ {F : Type u_1} {E : Type u_2} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E]
[alg : Algebra.IsAlgebraic F E],
(∀ (p : Polynomial F), p.Monic → Irreducible p → ∃ x, (Polynomial.aeval x) p = 0) → IsAlgClosure F E | null | true |
CategoryTheory.Limits.MulticospanIndex.mk | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | {J : CategoryTheory.Limits.MulticospanShape} →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(left : J.L → C) →
(right : J.R → C) →
((b : J.R) → left (J.fst b) ⟶ right b) →
((b : J.R) → left (J.snd b) ⟶ right b) → CategoryTheory.Limits.MulticospanIndex J C | null | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula.0.WeierstrassCurve.Projective.toAffine_negAddY_of_eq._simp_1_3 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | null | false |
_private.Batteries.Data.AssocList.Basic.0.Batteries.AssocList.foldlM.eq_1 | Batteries.Data.AssocList.Basic | ∀ {m : Type u_1 → Type u_2} {δ : Type u_1} {α : Type u_3} {β : Type u_4} [inst : Monad m] (f : δ → α → β → m δ) (x : δ),
Batteries.AssocList.foldlM f x Batteries.AssocList.nil = pure x | null | true |
bddAbove_smul_iff_of_neg._simp_1 | Mathlib.Algebra.Order.Module.Pointwise | ∀ {α : Type u_1} {β : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α]
[inst_3 : AddCommGroup β] [inst_4 : PartialOrder β] [IsOrderedAddMonoid β] [inst_6 : Module α β] [PosSMulMono α β]
{s : Set β} {a : α}, a < 0 → BddAbove (a • s) = BddBelow s | null | false |
Matrix.frobeniusNormedRing._proof_10 | Mathlib.Analysis.Matrix.Normed | ∀ {m : Type u_1} {α : Type u_2} [inst : Fintype m] [inst_1 : RCLike α] (n : ℕ) (a : Matrix m m α),
↑n.succ • a = ↑n • a + a | null | false |
ByteArray.utf8Decode?.eq_1 | Init.Data.String.Basic | ∀ (b : ByteArray), b.utf8Decode? = ByteArray.utf8Decode?.go b 0 #[] ⋯ | null | true |
_private.Batteries.Tactic.Init.0.Batteries.Tactic._aux_Batteries_Tactic_Init___macroRules_Batteries_Tactic_byContra_1.match_1 | Batteries.Tactic.Init | (motive : Option (Lean.TSyntax `term) → Sort u_1) →
(ty? : Option (Lean.TSyntax `term)) →
((ty? : Lean.TSyntax `term) → motive (some ty?)) → ((x : Option (Lean.TSyntax `term)) → motive x) → motive ty? | null | false |
MvFunctor.exists_iff_exists_of_mono | Mathlib.Control.Functor.Multivariate | ∀ {n : ℕ} {α β : TypeVec.{u} n} (F : TypeVec.{u} n → Type v) [inst : MvFunctor F] [LawfulMvFunctor F] {P : F α → Prop}
{q : F β → Prop} (f : α.Arrow β) (g : β.Arrow α),
TypeVec.comp f g = TypeVec.id → (∀ (u : F α), P u ↔ q (MvFunctor.map f u)) → ((∃ u, P u) ↔ ∃ u, q u) | null | true |
Lean.Lsp.SemanticTokenType.ctorElimType | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.SemanticTokenType → Sort u} → ℕ → Sort (max 1 u) | null | false |
Mathlib.Tactic.GCongr.GCongrHyp.isContra | Mathlib.Tactic.GCongr.Core | Mathlib.Tactic.GCongr.GCongrHyp → Bool | Whether the order of the two varying arguments is the opposite from in the conclusion. | true |
Subgroup.HasDetOne.recOn | Mathlib.NumberTheory.ModularForms.ArithmeticSubgroups | {n : Type u_1} →
[inst : Fintype n] →
[inst_1 : DecidableEq n] →
{R : Type u_2} →
[inst_2 : CommRing R] →
{Γ : Subgroup (GL n R)} →
{motive : Γ.HasDetOne → Sort u} →
(t : Γ.HasDetOne) →
((det_eq : ∀ {g : GL n R}, g ∈ Γ → Matrix.GeneralLinearGroup.d... | null | false |
String.Pos.next.congr_simp | Init.Data.String.Basic | ∀ {s : String} (pos pos_1 : s.Pos) (e_pos : pos = pos_1) (h : pos ≠ s.endPos), pos.next h = pos_1.next ⋯ | null | true |
IO.Error.illegalOperation.sizeOf_spec | Init.System.IOError | ∀ (osCode : UInt32) (details : String),
sizeOf (IO.Error.illegalOperation osCode details) = 1 + sizeOf osCode + sizeOf details | null | true |
ENNReal.div_eq_div_iff | Mathlib.Basic.ENNReal.Inv | ∀ {a b c d : ENNReal}, a ≠ 0 → a ≠ ⊤ → b ≠ 0 → b ≠ ⊤ → (c / b = d / a ↔ a * c = b * d) | null | true |
_private.Mathlib.Topology.Order.LeftRightNhds.0.TFAE_mem_nhdsGE.match_1_1 | Mathlib.Topology.Order.LeftRightNhds | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α} (s : Set α) (motive : (∃ u ∈ Set.Ioc a b, Set.Ico a u ⊆ s) → Prop)
(x : ∃ u ∈ Set.Ioc a b, Set.Ico a u ⊆ s),
(∀ (u : α) (umem : u ∈ Set.Ioc a b) (hu : Set.Ico a u ⊆ s), motive ⋯) → motive x | null | false |
CategoryTheory.ObjectProperty.instIsTriangulatedMinOfIsClosedUnderIsomorphisms | Mathlib.CategoryTheory.Triangulated.Subcategory | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} 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 | true |
FourierPair.fourierInv_fourier_eq | Mathlib.Analysis.Fourier.Notation | ∀ {E : Type u_5} {F : Type u_6} {inst : FourierTransform E F} {inst_1 : FourierTransformInv F E}
[self : FourierPair E F] (f : E), FourierTransformInv.fourierInv (FourierTransform.fourier f) = f | null | true |
Complex.log_zero | Mathlib.Analysis.SpecialFunctions.Complex.Log | Complex.log 0 = 0 | null | true |
CategoryTheory.Functor.rightDerived_fac_assoc | Mathlib.CategoryTheory.Functor.Derived.RightDerived | ∀ {C : Type u_3} {D : Type u_1} {H : Type u_2} [inst : CategoryTheory.Category.{v_1, u_3} C]
[inst_1 : CategoryTheory.Category.{v_2, u_1} D] [inst_2 : CategoryTheory.Category.{v_3, u_2} H]
(RF : CategoryTheory.Functor D H) {F : CategoryTheory.Functor C H} {L : CategoryTheory.Functor C D}
(α : F ⟶ L.comp RF) (W : ... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.