name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Matroid.isCircuit_iff_forall_ssubset | Mathlib.Combinatorics.Matroid.Circuit | ∀ {α : Type u_1} {M : Matroid α} {C : Set α}, M.IsCircuit C ↔ M.Dep C ∧ ∀ ⦃I : Set α⦄, I ⊂ C → M.Indep I | null | true |
_private.Init.Data.List.Nat.InsertIdx.0.List.insertIdx_eraseIdx._proof_1_1 | Init.Data.List.Nat.InsertIdx | ∀ {α : Type u_1} {i : ℕ} {as : List α} {j : ℕ}, ¬i ≤ j → ¬j ≤ i → False | null | false |
_private.Mathlib.Topology.Algebra.Module.Cardinality.0.cardinal_eq_of_mem_nhds_zero._simp_1_1 | Mathlib.Topology.Algebra.Module.Cardinality | ∀ {α : Type u_1} [inst : DivisionMonoid α] (a : α) (n : ℕ), (a ^ n)⁻¹ = a⁻¹ ^ n | null | false |
CategoryTheory.GrothendieckTopology.Cover.Arrow | Mathlib.CategoryTheory.Sites.Grothendieck | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X : C} → {J : CategoryTheory.GrothendieckTopology C} → J.Cover X → Type (max u v) | An auxiliary structure, used to define `S.index`. | true |
SDiff.mk._flat_ctor | Init.Core | {α : Type u} → (α → α → α) → SDiff α | null | false |
Int.lt_irrefl | Init.Data.Int.Order | ∀ (a : ℤ), ¬a < a | null | true |
IsQuasiSeparated.of_quasiSeparatedSpace | Mathlib.Topology.QuasiSeparated | ∀ {α : Type u_1} [inst : TopologicalSpace α] [QuasiSeparatedSpace α] (s : Set α), IsQuasiSeparated s | null | true |
Submodule.closedComplemented_iff_isClosed_exists_isClosed_isCompl | Mathlib.Analysis.Normed.Module.Complemented | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [CompleteSpace E] {p : Subspace 𝕜 E},
Submodule.ClosedComplemented p ↔ IsClosed ↑p ∧ ∃ q, IsClosed ↑q ∧ IsCompl p q | null | true |
Std.TreeSet.Equiv.diff_congr | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ t₃ t₄ : Std.TreeSet α cmp} [Std.TransCmp cmp],
t₁.Equiv t₃ → t₂.Equiv t₄ → (t₁ \ t₂).Equiv (t₃ \ t₄) | null | true |
LinearPMap.mem_ker_iff | 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] {f : E →ₛₗ.[σ] F} {x : E},
x ∈ f.ker ↔ ∃ y, x = ↑y ∧ ↑f y = 0 | null | true |
Antitone.neg | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} {β : Type u_1} [inst : AddGroup α] [inst_1 : Preorder α] [AddLeftMono α] [AddRightMono α]
[inst_4 : Preorder β] {f : β → α}, Antitone f → Monotone fun x => -f x | null | true |
IsStronglyAtomic | Mathlib.Order.Atoms | (α : Type u_5) → [Preorder α] → Prop | An order is strongly atomic if every nontrivial interval `[a, b]`
contains an element covering `a`. | true |
Std.Time.Year.Era.casesOn | Std.Time.Date.Unit.Year | {motive : Std.Time.Year.Era → Sort u} →
(t : Std.Time.Year.Era) → motive Std.Time.Year.Era.bce → motive Std.Time.Year.Era.ce → motive t | null | false |
CategoryTheory.MonoidalCategory.id_whiskerRight | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} {𝒞 : CategoryTheory.Category.{v, u} C} [self : CategoryTheory.MonoidalCategory C] (X Y : C),
CategoryTheory.MonoidalCategoryStruct.whiskerRight (CategoryTheory.CategoryStruct.id X) Y =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y) | null | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.mod_two_pow_add_mod_two_pow_add_bool_lt_two_pow_succ._proof_1_1 | Init.Data.BitVec.Bitblast | ∀ (x y i : ℕ) (c : Bool), c.toNat ≤ 1 → ¬x % 2 ^ i + (y % 2 ^ i + c.toNat) < 2 ^ i * 2 → False | null | false |
IsLocalization.ideal_eq_iInf_comap_map_away | Mathlib.RingTheory.Localization.Ideal | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Finset R},
Ideal.span ↑S = ⊤ → ∀ (I : Ideal R), I = ⨅ f ∈ S, Ideal.under R (Ideal.map (algebraMap R (Localization.Away f)) I) | **Alias** of `IsLocalization.ideal_eq_iInf_under_map_away`. | true |
_private.Mathlib.CategoryTheory.MorphismProperty.LocalClosure.0.CategoryTheory.MorphismProperty.sourceLocalClosure.sourceLocalClosure_iff_of_respectsLeft.match_1_5 | Mathlib.CategoryTheory.MorphismProperty.LocalClosure | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {K : CategoryTheory.Precoverage C}
[inst_1 : K.IsStableUnderBaseChange] [inst_2 : K.HasPullbacks] {X U : C} (g : U ⟶ X) (E : K.ZeroHypercover X)
(motive : (U_1 : C) → (v : U_1 ⟶ U) → (CategoryTheory.Precoverage.ZeroHypercover.pullback₁ g E).presieve₀ v ... | null | false |
SymAlg.mul_comm | Mathlib.Algebra.Symmetrized | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : AddCommSemigroup α] [inst_2 : One α] [inst_3 : OfNat α 2]
[inst_4 : Invertible 2] (a b : αˢʸᵐ), a * b = b * a | null | true |
Std.WP.StateT.instWPMonad._proof_1 | Std.WP.Monad.Instances | ∀ {m : Type u_2 → Type u_3} {EPred : Type u_4} {σ : Type u_2} {Pred : Type u_1} [inst : Monad m]
[inst_1 : Std.WP.Assertion Pred] [inst_2 : Std.WP.Assertion EPred] [inst_3 : Std.WP.WPMonad m Pred EPred]
{α β : Type u_2} (x : StateT σ m α) (f : α → StateT σ m β) (post : β → σ → Pred) (epost : EPred) (s : σ),
Lean.... | null | false |
Lean.TraceResult.failure.elim | Lean.Message | {motive : Lean.TraceResult → Sort u} →
(t : Lean.TraceResult) → t.ctorIdx = 1 → motive Lean.TraceResult.failure → motive t | null | false |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.Cache.addIte._proof_4 | Std.Sat.AIG.CNF | ∀ {aig : Std.Sat.AIG ℕ} {cnf : Std.Sat.CNF ℕ} (cache : Std.Sat.AIG.toCNF.Cache✝ aig cnf)
{cond ifTrue ifFalse : Std.Sat.AIG.Fanin},
∀ idx < aig.decls.size,
(Std.Sat.AIG.toCNF.Cache.marks✝ cache).size = aig.decls.size →
¬idx < (Std.Sat.AIG.toCNF.Cache.marks✝ cache).size → False | null | false |
OpenNormalAddSubgroup | Mathlib.Topology.Algebra.OpenSubgroup | (G : Type u) → [AddGroup G] → [TopologicalSpace G] → Type u | The type of open normal subgroups of a topological additive group. | true |
ClusterPt.limsInf_le | Mathlib.Topology.Order.LiminfLimsup | ∀ {α : Type u_2} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : TopologicalSpace α] [OrderTopology α]
{f : Filter α} {x : α},
ClusterPt x f → autoParam (Filter.IsBounded (fun x1 x2 => x1 ≥ x2) f) ClusterPt.limsInf_le._auto_1 → f.limsInf ≤ x | Every cluster point `x` of a filter `f` is greater than or equal to `f.limsInf`. | true |
_private.Mathlib.Data.Set.Pairwise.Basic.0.Set.pairwiseDisjoint_singleton'._proof_1_1 | Mathlib.Data.Set.Pairwise.Basic | ∀ {ι : Type u_1} (s : Set ι) ⦃x : ι⦄, x ∈ s → ∀ ⦃y : ι⦄, y ∈ s → ¬x = y → Disjoint {x} {y} | null | false |
ContinuousInf.rec | Mathlib.Topology.Order.Lattice | {L : Type u_1} →
[inst : TopologicalSpace L] →
[inst_1 : Min L] →
{motive : ContinuousInf L → Sort u} →
((continuous_inf : Continuous fun p => p.1 ⊓ p.2) → motive ⋯) → (t : ContinuousInf L) → motive t | null | false |
SeparationQuotient.mkAddMonoidHom._proof_2 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {M : Type u_1} [inst : TopologicalSpace M] [inst_1 : AddZeroClass M] [inst_2 : ContinuousAdd M] (a b : M),
SeparationQuotient.mk (a + b) = SeparationQuotient.mk a + SeparationQuotient.mk b | null | false |
AffineIndependent.smul | Mathlib.LinearAlgebra.AffineSpace.Independent | ∀ (k : Type u_1) {V : Type u_2} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V] {ι : Type u_4}
{G : Type u_5} [inst_3 : Group G] [inst_4 : DistribMulAction G V] [SMulCommClass G k V] {p : ι → V} {a : G},
AffineIndependent k p → AffineIndependent k (a • p) | **Alias** of the reverse direction of `affineIndependent_smul`. | true |
Module.End.mulSemiringActionToAlgEquiv_conjAct_surjective | Mathlib.LinearAlgebra.GeneralLinearGroup.AlgEquiv | ∀ {K : Type u_1} {V : Type u_2} [inst : Semifield K] [inst_1 : AddCommMonoid V] [inst_2 : Module K V]
[Module.Projective K V], Function.Surjective (MulSemiringAction.toAlgEquiv K (Module.End K V)) | Alternate statement of `AlgEquiv.eq_linearEquivConjAlgEquiv` for when `V = W`. | true |
LinearMap.BilinForm.flip_flip | Mathlib.LinearAlgebra.BilinearForm.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
LinearMap.BilinForm.flipHom ≪≫ₗ LinearMap.BilinForm.flipHom = LinearEquiv.refl R (LinearMap.BilinForm R M) | null | true |
_private.Lean.Elab.ConfigEval.Util.0.Lean.Elab.ConfigEval.planDerivation.go._unsafe_rec | Lean.Elab.ConfigEval.Util | Lean.Name →
(Lean.Expr → Lean.Elab.TermElabM (Array Lean.Expr)) →
Array Lean.Expr → Lean.ExprSet → Lean.Expr → Lean.Elab.TermElabM (Array Lean.Expr) | null | false |
CategoryTheory.MonoidalOpposite.mopMopEquivalenceFunctorMonoidal._proof_4 | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{X Y : Cᴹᵒᵖᴹᵒᵖ} (X' : Cᴹᵒᵖᴹᵒᵖ) (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft
((CategoryTheory.MonoidalOpposite.mopMopEquivalence C).functor.o... | null | false |
LieAlgebra.ExtendScalars.instLieAlgebra._proof_1 | Mathlib.Algebra.Lie.BaseChange | ∀ (R : Type u_3) (A : Type u_1) (L : Type u_2) [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
[inst_3 : LieRing L] [inst_4 : LieAlgebra R L], SMulCommClass A A (TensorProduct R A L) | null | false |
CategoryTheory.SimplicialObject.δ_δ₀Iter._auto_1 | Mathlib.AlgebraicTopology.SimplicialObject.DeltaZeroIter | Lean.Syntax | null | false |
_private.Mathlib.Tactic.NormNum.Basic.0.Mathlib.Meta.NormNum.isNat_natSub.match_1_1 | Mathlib.Tactic.NormNum.Basic | ∀
(motive :
(x x_1 x_2 x_3 x_4 : ℕ) →
Mathlib.Meta.NormNum.IsNat x x_2 → Mathlib.Meta.NormNum.IsNat x_1 x_3 → x_2.sub x_3 = x_4 → Prop)
(x x_1 x_2 x_3 x_4 : ℕ) (x_5 : Mathlib.Meta.NormNum.IsNat x x_2) (x_6 : Mathlib.Meta.NormNum.IsNat x_1 x_3)
(x_7 : x_2.sub x_3 = x_4),
(∀ (n n_1 : ℕ), motive (↑n) (↑n... | null | false |
_private.Batteries.Util.ProofWanted.0.elabWanted.match_3 | Batteries.Util.ProofWanted | (motive : Option (Lean.TSyntax `term) → Sort u_1) →
(x : Option (Lean.TSyntax `term)) →
((t : Lean.TSyntax `term) → motive (some t)) → ((x : Option (Lean.TSyntax `term)) → motive x) → motive x | null | false |
_private.Mathlib.Tactic.IrreducibleDef.0.Lean.Elab.Command._aux_Mathlib_Tactic_IrreducibleDef___elabRules_Lean_Elab_Command_command_Irreducible_def_____1.match_3 | Mathlib.Tactic.IrreducibleDef | (motive : Option (Lean.TSyntax `Lean.Parser.Command.unsafe) → Sort u_1) →
(uns : Option (Lean.TSyntax `Lean.Parser.Command.unsafe)) →
((uns : Lean.TSyntax `Lean.Parser.Command.unsafe) → motive (some uns)) →
((x : Option (Lean.TSyntax `Lean.Parser.Command.unsafe)) → motive x) → motive uns | null | false |
Std.DTreeMap.Const.getKey?_filter | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
{f : α → β → Bool} {k : α},
(Std.DTreeMap.filter f t).getKey? k = (t.getKey? k).pfilter fun x h' => f x (Std.DTreeMap.Const.get t x ⋯) | null | true |
instLieRingAddGroupLieAlgebra | Mathlib.Geometry.Manifold.GroupLieAlgebra | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{H : Type u_2} →
[inst_1 : TopologicalSpace H] →
{E : Type u_3} →
[inst_2 : NormedAddCommGroup E] →
[inst_3 : NormedSpace 𝕜 E] →
{I : ModelWithCorners 𝕜 E H} →
{G : Type u_4} →
... | The tangent space at the identity of an additive Lie group is a Lie ring, for the
bracket given by the Lie bracket of invariant vector fields. | true |
LocallyConstant.instSub | Mathlib.Topology.LocallyConstant.Algebra | {X : Type u_1} → {Y : Type u_2} → [inst : TopologicalSpace X] → [Sub Y] → Sub (LocallyConstant X Y) | null | true |
_private.Mathlib.Algebra.Homology.SpectralSequence.ComplexShape.0.ComplexShape.spectralSequenceNat._proof_1 | Mathlib.Algebra.Homology.SpectralSequence.ComplexShape | ∀ (u : ℤ × ℤ) {i j j' : ℕ × ℕ},
↑i.1 + u.1 = ↑j.1 ∧ ↑i.2 + u.2 = ↑j.2 → ↑i.1 + u.1 = ↑j'.1 ∧ ↑i.2 + u.2 = ↑j'.2 → j.1 = j'.1 | null | false |
Lean.Elab.Do.Context.monadInfo | Lean.Elab.Do.Basic | Lean.Elab.Do.Context → Lean.Elab.Do.MonadInfo | Inferred and cached information about the monad. | true |
Fin.sub_castAdd_eq_castAdd_sub_of_le | Mathlib.Data.Fin.SuccPred | ∀ {m n : ℕ} {a b : Fin n}, b ≤ a → Fin.castAdd m a - Fin.castAdd m b = Fin.castAdd m (a - b) | null | true |
CategoryTheory.Limits.colimit.comp_coconePointUniqueUpToIso_inv_assoc._to_dual_1 | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasLimit F] {c : CategoryTheory.Limits.Cone F}
(hc : CategoryTheory.Limits.IsLimit c) (j : J) {Z : C} (h : Z ⟶ c.pt),
CategoryTheory... | null | false |
instPartialOrderAddGroupCone.eq_1 | Mathlib.Algebra.Order.Group.Cone | ∀ (G : Type u_1) [inst : AddCommGroup G], instPartialOrderAddGroupCone G = PartialOrder.ofSetLike (AddGroupCone G) | null | true |
Interval.coe_inj | Mathlib.Order.Interval.Basic | ∀ {α : Type u_1} [inst : LE α] {s t : NonemptyInterval α}, ↑s = ↑t ↔ s = t | null | true |
Matrix.charpoly_fin_two | Mathlib.LinearAlgebra.Matrix.Charpoly.Coeff | ∀ {R : Type u} [inst : CommRing R] [Nontrivial R] (M : Matrix (Fin 2) (Fin 2) R),
M.charpoly = Polynomial.X ^ 2 - Polynomial.C M.trace * Polynomial.X + Polynomial.C M.det | null | true |
Matrix.conjTranspose_submatrix | Mathlib.LinearAlgebra.Matrix.ConjTranspose | ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type v} [inst : Star α] (A : Matrix m n α)
(r : l → m) (c : o → n), (A.submatrix r c).conjTranspose = A.conjTranspose.submatrix c r | null | true |
ofColex_toColex | Mathlib.Order.Lex | ∀ {α : Type u_1} (a : α), ofColex (toColex a) = a | null | true |
MeasureTheory.integrable_comp_exp | Mathlib.MeasureTheory.Integral.IntegralEqImproper | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] (g : ℝ → E),
MeasureTheory.Integrable (fun x => Real.exp x • g (Real.exp x)) MeasureTheory.volume ↔
MeasureTheory.IntegrableOn g (Set.Ioi 0) MeasureTheory.volume | null | true |
himp_top | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : GeneralizedHeytingAlgebra α] {a : α}, a ⇨ ⊤ = ⊤ | `p → true` | true |
csInf_Ioi | Mathlib.Order.ConditionallyCompleteLattice.Basic | ∀ {α : Type u_1} [inst : ConditionallyCompleteLattice α] {a : α} [NoMaxOrder α] [DenselyOrdered α], sInf (Set.Ioi a) = a | null | true |
Rep.ofMulActionSubsingletonIsoTrivial | Mathlib.RepresentationTheory.Rep.Basic | (k : Type u) →
(G : Type v) →
[inst : Ring k] →
[inst_1 : Monoid G] →
(H : Type u) →
[Subsingleton H] → [MulOneClass H] → [inst_4 : MulAction G H] → Rep.ofMulAction k G H ≅ Rep.trivial k G k | When `H = {1}`, the `G`-representation on `k[H]` induced by an action of `G` on `H` is
isomorphic to the trivial representation on `k`. | true |
_private.Mathlib.Dynamics.OmegaLimit.0.mem_omegaLimit_iff_frequently._simp_1_1 | Mathlib.Dynamics.OmegaLimit | ∀ {α : Type u} {f : Filter α} {P : α → Prop}, (∃ᶠ (x : α) in f, P x) = ∀ {U : Set α}, U ∈ f → ∃ x ∈ U, P x | null | false |
Finset.ordConnected_range_val | Mathlib.Data.Finset.Grade | ∀ {α : Type u_1}, (Set.range Finset.val).OrdConnected | Finsets form an order-connected suborder of multisets. | true |
ringHomEquivModuleIsScalarTower._proof_4 | Mathlib.Algebra.Module.RingHom | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : Semiring S] (x : { _inst // IsScalarTower R S S }),
⟨Module.compHom S
(match x with
| ⟨val, property⟩ => RingHom.smulOneHom),
⋯⟩ =
x | null | false |
NonemptyInterval.subtractionCommMonoid._proof_11 | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [inst_2 : IsOrderedAddMonoid α]
(a b : NonemptyInterval α), a + b = b + a | null | false |
Lean.PrettyPrinter.Delaborator.TopDownAnalyze.App.Context.f | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | Lean.PrettyPrinter.Delaborator.TopDownAnalyze.App.Context → Lean.Expr | null | true |
Ideal.quotientInfRingEquivPiQuotient._proof_2 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u_1} [inst : CommRing R] {ι : Type u_2} (f : ι → Ideal R) (i : ι), (f i).IsTwoSided | null | false |
CategoryTheory.SubobjectRepresentableBy.χ.eq_1 | Mathlib.CategoryTheory.Subobject.Classifier.Defs | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C] {Ω : C}
(h : CategoryTheory.SubobjectRepresentableBy Ω) {U X : C} (m : U ⟶ X) [inst_2 : CategoryTheory.Mono m],
h.χ m = h.homEquiv.symm (CategoryTheory.Subobject.mk m) | null | true |
AlgEquiv.equivCongr_symm | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type uR} {A₁ : Type uA₁} {A₂ : Type uA₂} {A₁' : Type uA₁'} {A₂' : Type uA₂'} [inst : CommSemiring R]
[inst_1 : Semiring A₁] [inst_2 : Semiring A₂] [inst_3 : Semiring A₁'] [inst_4 : Semiring A₂'] [inst_5 : Algebra R A₁]
[inst_6 : Algebra R A₂] [inst_7 : Algebra R A₁'] [inst_8 : Algebra R A₂'] (e : A₁ ≃ₐ[R] A₂... | null | true |
_private.Mathlib.LinearAlgebra.AffineSpace.Combination.0.Finset.weightedVSub_eq_linear_combination._simp_1_1 | Mathlib.LinearAlgebra.AffineSpace.Combination | ∀ {ι : Type u_1} {R : Type u_5} {M : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{f : ι → R} {s : Finset ι} {x : M}, ∑ i ∈ s, f i • x = (∑ i ∈ s, f i) • x | null | false |
CategoryTheory.Limits.HasZeroMorphisms.instSubsingleton | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C], Subsingleton (CategoryTheory.Limits.HasZeroMorphisms C) | null | true |
CategoryTheory.MorphismProperty.transfiniteCompositionsOfShape_le_transfiniteCompositions | Mathlib.CategoryTheory.MorphismProperty.TransfiniteComposition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C) (J : Type w)
[inst_1 : LinearOrder J] [inst_2 : SuccOrder J] [inst_3 : OrderBot J] [inst_4 : WellFoundedLT J],
W.transfiniteCompositionsOfShape J ≤ CategoryTheory.MorphismProperty.transfiniteCompositions.{w, v, u} W | null | true |
Subfield.relrank_mul_relrank_eq_inf_relrank | Mathlib.FieldTheory.Relrank | ∀ {E : Type v} [inst : Field E] (A : Subfield E) {B C : Subfield E},
B ≤ C → A.relrank B * B.relrank C = (A ⊓ B).relrank C | null | true |
Finset.insert_inter_of_notMem | Mathlib.Data.Finset.Lattice.Lemmas | ∀ {α : Type u_1} [inst : DecidableEq α] {s₁ s₂ : Finset α} {a : α}, a ∉ s₂ → insert a s₁ ∩ s₂ = s₁ ∩ s₂ | null | true |
Topology.RelCWComplex.FiniteDimensional.mk._flat_ctor | Mathlib.Topology.CWComplex.Classical.Finite | ∀ {X : Type u} [inst : TopologicalSpace X] {C D : Set X} [inst_1 : Topology.RelCWComplex C D],
(∀ᶠ (n : ℕ) in Filter.atTop, IsEmpty (Topology.RelCWComplex.cell C n)) → Topology.RelCWComplex.FiniteDimensional C | null | false |
AddCon.toSetoid_bot | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Add M], ⊥.toSetoid = ⊥ | null | true |
CategoryTheory.Triangulated.TStructure.eTruncLTGEIsoGELT_hom_app_fac'_assoc | Mathlib.CategoryTheory.Triangulated.TStructure.ETrunc | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryT... | null | true |
CategoryTheory.GrothendieckTopology.Cover.Arrow.Relation._sizeOf_1 | Mathlib.CategoryTheory.Sites.Grothendieck | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{X : C} →
{J : CategoryTheory.GrothendieckTopology C} →
{S : J.Cover X} → {I₁ I₂ : S.Arrow} → [SizeOf C] → I₁.Relation I₂ → ℕ | null | false |
MeasureTheory.AEFinStronglyMeasurable.mul | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace β]
{f g : α → β} [inst_1 : MulZeroClass β] [ContinuousMul β],
MeasureTheory.AEFinStronglyMeasurable f μ →
MeasureTheory.AEFinStronglyMeasurable g μ → MeasureTheory.AEFinStronglyMeasurable (f * g) μ | null | true |
Subgroup.card_le_card_group | Mathlib.Algebra.Group.Subgroup.Finite | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) [Finite G], Nat.card ↥H ≤ Nat.card G | null | true |
CommRingCat.hasLimitsOfSize | Mathlib.Algebra.Category.Ring.Limits | ∀ [UnivLE.{v, u}], CategoryTheory.Limits.HasLimitsOfSize.{w, v, u, u + 1} CommRingCat | The category of commutative rings has all limits. | true |
Lean.Parser.manyIndent.formatter | Lean.Parser.Extra | Lean.PrettyPrinter.Formatter → Lean.PrettyPrinter.Formatter | null | true |
MeasureTheory.AEEqFun.le_inf | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace β]
[inst_2 : SemilatticeInf β] [inst_3 : ContinuousInf β] (f' f g : α →ₘ[μ] β), f' ≤ f → f' ≤ g → f' ≤ f ⊓ g | null | true |
Std.Tactic.BVDecide.Normalize.Int16.toBitVec_ite | Std.Tactic.BVDecide.Normalize.BitVec | ∀ {c : Prop} {t e : Int16} [inst : Decidable c], (if c then t else e).toBitVec = if c then t.toBitVec else e.toBitVec | null | true |
Std.HashSet.size_le_size_insertMany_list | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.HashSet α} [EquivBEq α] [LawfulHashable α] {l : List α},
m.size ≤ (m.insertMany l).size | null | true |
_private.Lean.Elab.Do.Legacy.0.Lean.Elab.Term.Do.ToTerm.toTerm.go.match_1 | Lean.Elab.Do.Legacy | (motive : Lean.Elab.Term.Do.Code → Sort u_1) →
(c : Lean.Elab.Term.Do.Code) →
((ref val : Lean.Syntax) → motive (Lean.Elab.Term.Do.Code.return ref val)) →
((ref : Lean.Syntax) → motive (Lean.Elab.Term.Do.Code.continue ref)) →
((ref : Lean.Syntax) → motive (Lean.Elab.Term.Do.Code.break ref)) →
... | null | false |
Topology.IsInducing.generalLinearGroup_map | Mathlib.Topology.Algebra.Group.Matrix | ∀ {n : Type u_1} {R : Type u_2} {S : Type u_3} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing R]
[inst_3 : TopologicalSpace R] [inst_4 : CommRing S] [inst_5 : TopologicalSpace S] {f : R →+* S},
Topology.IsInducing ⇑f → Topology.IsInducing ⇑(Matrix.GeneralLinearGroup.map f) | null | true |
Lean.Widget.MsgEmbed.expr | Lean.Widget.InteractiveDiagnostic | Lean.Widget.CodeWithInfos → Lean.Widget.MsgEmbed | A piece of Lean code with elaboration/typing data.
Note: does not necessarily correspond to an `Expr`, the name is for RPC API compatibility. | true |
PartOrdEmb.orderIsoEquivIso._proof_2 | Mathlib.Order.Category.PartOrdEmb | ∀ {α β : PartOrdEmb}, Function.RightInverse PartOrdEmb.Iso.mk PartOrdEmb.orderIsoOfIso | null | false |
CategoryTheory.ShortComplex.unopFunctor_obj | Mathlib.Algebra.Homology.ShortComplex.Basic | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex Cᵒᵖ), (CategoryTheory.ShortComplex.unopFunctor C).obj S = Opposite.op S.unop | null | true |
Field.toEuclideanDomain.match_3 | Mathlib.Algebra.EuclideanDomain.Field | ∀ {K : Type u_1} [inst : Field K] (x x_1 : K) (motive : x * x_1 = 0 ∧ x ≠ 0 → Prop) (x_2 : x * x_1 = 0 ∧ x ≠ 0),
(∀ (hab : x * x_1 = 0) (hna : x ≠ 0), motive ⋯) → motive x_2 | null | false |
Lean.Omega.LinearCombo.neg_eval | Init.Omega.LinearCombo | ∀ (lc : Lean.Omega.LinearCombo) (v : Lean.Omega.Coeffs), (-lc).eval v = -lc.eval v | null | true |
MvPolynomial.degreeOf_rename_of_injective | Mathlib.Algebra.MvPolynomial.Degrees | ∀ {R : Type u} {σ : Type u_1} {τ : Type u_2} [inst : CommSemiring R] {p : MvPolynomial σ R} {f : σ → τ},
Function.Injective f → ∀ (i : σ), MvPolynomial.degreeOf (f i) ((MvPolynomial.rename f) p) = MvPolynomial.degreeOf i p | null | true |
CategoryTheory.Idempotents.app_p_comm | Mathlib.CategoryTheory.Idempotents.FunctorCategories | ∀ {J : Type u_1} {C : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C]
{P Q : CategoryTheory.Idempotents.Karoubi (CategoryTheory.Functor J C)} (f : P ⟶ Q) (X : J),
CategoryTheory.CategoryStruct.comp (P.p.app X) (f.f.app X) =
CategoryTheory.CategoryStruct.... | null | true |
trapezoidal_error | Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule | (ℝ → ℝ) → ℕ → ℝ → ℝ → ℝ | The absolute error of trapezoidal integration. | true |
CategoryTheory.Functor.FullyFaithful.isoEquiv._proof_2 | Mathlib.CategoryTheory.Functor.FullyFaithful | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] {F : CategoryTheory.Functor C D} (hF : F.FullyFaithful) {X Y : C},
Function.LeftInverse hF.preimageIso F.mapIso | null | false |
_private.Mathlib.Topology.ContinuousMap.Ideals.0.ContinuousMap.mem_setOfIdeal._simp_1_2 | Mathlib.Topology.ContinuousMap.Ideals | ∀ {α : Type u} (s : Set α) (x : α), (x ∈ sᶜ) = (x ∉ s) | null | false |
CategoryTheory.EffectiveEpiStruct.mk.sizeOf_spec | Mathlib.CategoryTheory.EffectiveEpi.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X Y : C} {f : Y ⟶ X} [inst_1 : SizeOf C]
(desc :
{W : C} →
(e : Y ⟶ W) →
(∀ {Z : C} (g₁ g₂ : Z ⟶ Y),
CategoryTheory.CategoryStruct.comp g₁ f = CategoryTheory.CategoryStruct.comp g₂ f →
CategoryTheory.CategorySt... | null | true |
List.zipWith_nil_left | Init.Data.List.Basic | ∀ {α : Type u} {β : Type v} {γ : Type w} {l : List β} {f : α → β → γ}, List.zipWith f [] l = [] | null | true |
Lean.Elab.Tactic.Location.recOn | Lean.Elab.Tactic.Location | {motive : Lean.Elab.Tactic.Location → Sort u} →
(t : Lean.Elab.Tactic.Location) →
motive Lean.Elab.Tactic.Location.wildcard →
((hypotheses : Array Lean.Syntax) → (type : Bool) → motive (Lean.Elab.Tactic.Location.targets hypotheses type)) →
motive t | null | false |
Submodule.quotientEquivPiSpan._proof_6 | Mathlib.LinearAlgebra.FreeModule.Finite.Quotient | ∀ {R : Type u_1} [inst : CommRing R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) | null | false |
zsmul_add | Mathlib.Algebra.Group.Basic | ∀ {α : Type u_1} [inst : SubtractionCommMonoid α] (a b : α) (n : ℤ), n • (a + b) = n • a + n • b | null | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift.0.CochainComplex.HomComplex.Cochain.leftUnshift_leftShift._proof_1_1 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | ∀ (n' q : ℤ), q - n' + n' = q | null | false |
fderivPolarCoordSymm._proof_9 | Mathlib.Analysis.SpecialFunctions.PolarCoord | RingHomInvPair (RingHom.id ℝ) (RingHom.id ℝ) | null | false |
Multiplicative.isIsometricSMul | Mathlib.Topology.MetricSpace.IsometricSMul | ∀ {M : Type u_2} {X : Type u_3} [inst : VAdd M X] [inst_1 : PseudoEMetricSpace X] [IsIsometricVAdd M X],
IsIsometricSMul (Multiplicative M) X | null | true |
Subfield.relrank_inf_mul_relrank | Mathlib.FieldTheory.Relrank | ∀ {E : Type v} [inst : Field E] (A B C : Subfield E), A.relrank (B ⊓ C) * B.relrank C = (A ⊓ B).relrank C | null | true |
Lean.Compiler.LCNF.Decl.instantiateParamsLevelParams | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.Decl pu → List Lean.Level → Array (Lean.Compiler.LCNF.Param pu) | null | true |
_private.Mathlib.CategoryTheory.Shift.ShiftedHomOpposite.0.CategoryTheory.ShiftedHom.opEquiv'_add_symm._proof_1_5 | Mathlib.CategoryTheory.Shift.ShiftedHomOpposite | ∀ (n m a a' a'' : ℤ), n + a = a' → m + a' = a'' → a + n + m = a'' | null | false |
Std.Tactic.BVDecide.Frontend.Normalize.BitVec.bif_eq_not_bif' | Std.Tactic.BVDecide.Normalize.Equal | ∀ {w : ℕ} (d : Bool) (a b c : BitVec w),
((bif d then a else c) == ~~~bif d then b else c) = bif d then a == ~~~b else c == ~~~c | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.