name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
FreeAddMonoid.toList.eq_1 | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1}, FreeAddMonoid.toList = Equiv.refl (FreeAddMonoid α) | null | true |
StarMulEquiv.coe_trans | Mathlib.Algebra.Star.MonoidHom | ∀ {A : Type u_2} {B : Type u_3} {C : Type u_4} [inst : Mul A] [inst_1 : Mul B] [inst_2 : Mul C] [inst_3 : Star A]
[inst_4 : Star B] [inst_5 : Star C] (e₁ : A ≃⋆* B) (e₂ : B ≃⋆* C), ⇑(e₁.trans e₂) = ⇑e₂ ∘ ⇑e₁ | null | true |
AlgebraicClosure.instGroupWithZero._proof_8 | Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure | ∀ (k : Type u_1) [inst : Field k],
autoParam (∀ (a : AlgebraicClosure k), AlgebraicClosure.instGroupWithZero._aux_6 k 0 a = 1)
DivInvMonoid.zpow_zero'._autoParam | null | false |
TensorProduct.quotientTensorQuotientEquiv._proof_9 | Mathlib.LinearAlgebra.TensorProduct.Quotient | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : AddCommGroup N] [inst_4 : Module R N], IsScalarTower R R (TensorProduct R M N) | null | false |
CategoryTheory.Functor.whiskeringLeft₃ObjObjMap_app | Mathlib.CategoryTheory.Whiskering | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {D₁ : Type u_4} {D₂ : Type u_5} {D₃ : Type u_6}
[inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_3} C₃] [inst_3 : CategoryTheory.Category.{v_4, u_4} D₁]
[inst_4 : CategoryTheo... | null | true |
PolynomialLaw.instZero._proof_2 | Mathlib.RingTheory.PolynomialLaw.Basic | ∀ {R : Type u_1} [inst : CommSemiring 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] {S : Type u_1} [inst_5 : CommSemiring S] [inst_6 : Algebra R S]
{S' : Type u_1} [inst_7 : CommSemiring S'] [inst_8 : Algebra R S'] (φ : S →ₐ[R] S')... | null | false |
Lean.Lsp.Command.recOn | Lean.Data.Lsp.Basic | {motive : Lean.Lsp.Command → Sort u} →
(t : Lean.Lsp.Command) →
((title command : String) →
(arguments? : Option (Array Lean.Json)) →
motive { title := title, command := command, arguments? := arguments? }) →
motive t | null | false |
FirstOrder.Language.isFraisse_finite_linear_order | Mathlib.ModelTheory.Order | FirstOrder.Language.IsFraisse {M | Finite ↑M ∧ ↑M ⊨ FirstOrder.Language.order.linearOrderTheory} | The class of finite models of the theory of linear orders is Fraïssé. | true |
Colex.instAddMonoid.eq_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : AddMonoid α],
Colex.instAddMonoid =
{ toAddSemigroup := Colex.instAddSemigroup, toZero := Colex.instZero, zero_add := ⋯, add_zero := ⋯,
nsmul := Colex.instAddMonoid._aux_3, nsmul_zero := ⋯, nsmul_succ := ⋯ } | null | true |
AlgebraicGeometry.Scheme.Modules.Hom.isIso_iff_isIso_app | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {X : AlgebraicGeometry.Scheme} {M N : X.Modules} {φ : M ⟶ N},
CategoryTheory.IsIso φ ↔ ∀ (U : X.Opens), CategoryTheory.IsIso (AlgebraicGeometry.Scheme.Modules.Hom.app φ U) | null | true |
TestFunction.monoCLM._proof_4 | Mathlib.Analysis.Distribution.TestFunction | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] {Ω₁ Ω₂ : TopologicalSpace.Opens E} {n₁ n₂ : ℕ∞}
(K : TopologicalSpace.Compacts E), ↑K ⊆ ↑Ω₁ → n₂ ≤ n₁ ∧ Ω₁ ≤ Ω₂ → ↑K ⊆ ↑Ω₂ | null | false |
CategoryTheory.Cat.freeMapIdIso | Mathlib.CategoryTheory.Category.Quiv | (V : Type u_1) →
[inst : Quiver V] → CategoryTheory.Cat.freeMap (𝟭q V) ≅ CategoryTheory.Functor.id (CategoryTheory.Paths V) | The functor `free : Quiv ⥤ Cat` preserves identities up to natural isomorphism and in fact up
to equality. | true |
ULift.addGroup._proof_4 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u_2} [inst : AddGroup α] (x x_1 : ULift.{u_1, u_2} α), Equiv.ulift (x - x_1) = Equiv.ulift (x - x_1) | null | false |
CategoryTheory.Limits.Types.colimitCocone | Mathlib.CategoryTheory.Limits.Types.Colimits | {J : Type v} →
[inst : CategoryTheory.Category.{w, v} J] →
(F : CategoryTheory.Functor J (Type u)) → [Small.{u, max u v} F.ColimitType] → CategoryTheory.Limits.Cocone F | (internal implementation) the colimit cocone of a functor,
implemented as a quotient of a sigma type
| true |
_private.Mathlib.Tactic.Widget.Conv.0.Mathlib.Tactic.Conv.pathToStx.match_3 | Mathlib.Tactic.Widget.Conv | (motive : Mathlib.Tactic.Conv.Path → Sort u_1) →
(path : Mathlib.Tactic.Conv.Path) →
((arg : ℕ) →
(all : Bool) → (next : Mathlib.Tactic.Conv.Path) → motive (Mathlib.Tactic.Conv.Path.arg arg all next)) →
((next : Mathlib.Tactic.Conv.Path) → motive next.type) →
((name : Lean.Name) → (next : Ma... | null | false |
Nat.binaryRec'._proof_1 | Mathlib.Data.Nat.BinaryRec | ∀ {motive : ℕ → Sort u_1} (b : Bool) (n : ℕ) (ih : motive n), ¬(n = 0 → b = true) → Nat.bit b n = 0 | null | false |
PrincipalSeg.ordinal_type_lt | Mathlib.SetTheory.Ordinal.Basic | ∀ {α β : Type u_1} {r : α → α → Prop} {s : β → β → Prop} [inst : IsWellOrder α r] [inst_1 : IsWellOrder β s]
(h : PrincipalSeg r s), Ordinal.type r < Ordinal.type s | null | true |
Mathlib.Tactic.Abel.AbelNF.Config.mk._flat_ctor | Mathlib.Tactic.Abel | Lean.Meta.TransparencyMode → Bool → Bool → Mathlib.Tactic.Abel.AbelMode → Mathlib.Tactic.Abel.AbelNF.Config | null | false |
Nat.recOnPrimePow._proof_2 | Mathlib.Data.Nat.Factorization.Induction | ∀ (k : ℕ), Nat.Prime (k + 2).minFac | null | false |
Mathlib.Tactic.ITauto.IProp.and'.noConfusion | Mathlib.Tactic.ITauto | {P : Sort u} →
{a : Mathlib.Tactic.ITauto.AndKind} →
{a_1 a_2 : Mathlib.Tactic.ITauto.IProp} →
{a' : Mathlib.Tactic.ITauto.AndKind} →
{a'_1 a'_2 : Mathlib.Tactic.ITauto.IProp} →
Mathlib.Tactic.ITauto.IProp.and' a a_1 a_2 = Mathlib.Tactic.ITauto.IProp.and' a' a'_1 a'_2 →
(a = a'... | null | false |
AlgebraicGeometry.Scheme.LocalRepresentability.glueData._proof_14 | Mathlib.AlgebraicGeometry.Sites.Representability | ∀ {F : CategoryTheory.Sheaf AlgebraicGeometry.Scheme.zariskiTopology (Type u_1)} {ι : Type u_1}
{X : ι → AlgebraicGeometry.Scheme} {f : (i : ι) → CategoryTheory.yoneda.obj (X i) ⟶ F.obj}
(hf : ∀ (i : ι), AlgebraicGeometry.IsOpenImmersion.presheaf (f i)) (i j k : ι),
CategoryTheory.CategoryStruct.comp
(⋯.lif... | null | false |
Mathlib.Meta.FunProp.LambdaTheorems._sizeOf_1 | Mathlib.Tactic.FunProp.Theorems | Mathlib.Meta.FunProp.LambdaTheorems → ℕ | null | false |
_private.Mathlib.NumberTheory.PellMatiyasevic.0.Pell.matiyasevic.match_1_5 | Mathlib.NumberTheory.PellMatiyasevic | ∀ {a k x y : ℕ}
(motive :
(x = 1 ∧ y = 0 ∨
∃ u v s t b,
x * x - (a * a - 1) * y * y = 1 ∧
u * u - (a * a - 1) * v * v = 1 ∧
s * s - (b * b - 1) * t * t = 1 ∧
1 < b ∧ b ≡ 1 [MOD 4 * y] ∧ b ≡ a [MOD u] ∧ 0 < v ∧ y * y ∣ v ∧ s ≡ x [MOD u] ∧ t ≡ k [MOD 4 * y... | null | false |
Affine.Simplex.instFintypePointsWithCircumcenterIndex.match_3 | Mathlib.Geometry.Euclidean.Circumcenter | (n : ℕ) →
(motive : Fin (n + 1) ⊕ Unit → Sort u_1) →
(x : Fin (n + 1) ⊕ Unit) →
((a : Fin (n + 1)) → motive (Sum.inl a)) → (Unit → motive (Sum.inr PUnit.unit)) → motive x | null | false |
Std.Internal.Do.PredTrans | Std.Internal.Do.PredTrans | Type u → Type v → Type w → Type (max (max u v) w) | A monotone predicate transformer from postconditions to preconditions.
Given a return type `α`, a lattice `Pred` for assertions, and an exception assertion type `EPred`,
`PredTrans Pred EPred α` wraps a function `(α → Pred) → EPred → Pred`. | true |
String.Slice.skipSuffix?_prop_eq_some_iff | Init.Data.String.Lemmas.Pattern.TakeDrop.Pred | ∀ {P : Char → Prop} [inst : DecidablePred P] {s : String.Slice} {pos : s.Pos},
s.skipSuffix? P = some pos ↔ ∃ (h : s.endPos ≠ s.startPos), pos = s.endPos.prev h ∧ P ((s.endPos.prev h).get ⋯) | null | true |
Submodule.annihilator | Mathlib.RingTheory.Ideal.Maps | {R : Type u_1} →
{M : Type u_2} → [inst : Semiring R] → [inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → Submodule R M → Ideal R | `N.annihilator` is the ideal of all elements `r : R` such that `r • N = 0`. | true |
Lean.Meta.instInhabitedCaseArraySizesSubgoal.default | Lean.Meta.Match.CaseArraySizes | Lean.Meta.CaseArraySizesSubgoal | null | true |
_private.Mathlib.RingTheory.Spectrum.Prime.Topology.0.PrimeSpectrum.stableUnderSpecialization_singleton._simp_1_5 | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∀ (a : α), a = a' → p a) = p a' | null | false |
WellFoundedLT.finite_of_iSupIndep | Mathlib.Order.CompactlyGenerated.Basic | ∀ {α : Type u_2} [inst : CompleteLattice α] [WellFoundedLT α] {ι : Type u_3} {t : ι → α},
iSupIndep t → (∀ (i : ι), t i ≠ ⊥) → Finite ι | null | true |
FiniteField.instFieldExtension._proof_68 | Mathlib.FieldTheory.Finite.Extension | ∀ (k : Type u_1) [inst : Field k] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : CharP k p] (n : ℕ),
autoParam (∀ (q : ℚ≥0) (a : FiniteField.Extension k p n), FiniteField.instFieldExtension._aux_66 k p n q a = ↑q * a)
DivisionRing.nnqsmul_def._autoParam | null | false |
Std.Http.Header.Expect.parse | Std.Http.Data.Headers.Basic | Std.Http.Header.Value → Option Std.Http.Header.Expect | Parses an `Expect` header.
Succeeds only if the value is exactly `100-continue`
(case-insensitive, trimmed).
| true |
summable_star_iff' | Mathlib.Topology.Algebra.InfiniteSum.Constructions | ∀ {α : Type u_1} {β : Type u_2} {L : SummationFilter β} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α]
[inst_2 : StarAddMonoid α] [ContinuousStar α] {f : β → α}, Summable (star f) L ↔ Summable f L | null | true |
CategoryTheory.Limits.SequentialProduct.functorObj_eq_neg | Mathlib.CategoryTheory.Limits.Shapes.SequentialProduct | ∀ {C : Type u_1} {M N : ℕ → C} {n m : ℕ}, ¬m < n → (fun i => if x : i < n then M i else N i) m = N m | null | true |
Lean.Grind.Linarith.Expr.toPolyN._f | Init.Grind.Module.NatModuleNorm | (x : Lean.Grind.Linarith.Expr) → Lean.Grind.Linarith.Expr.below x → Lean.Grind.Linarith.Poly | null | false |
AddAction.vadd_mem_fixedBy_iff_mem_fixedBy | Mathlib.GroupTheory.GroupAction.FixedPoints | ∀ {α : Type u_1} {G : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G α] {a : α} {g : G},
g +ᵥ a ∈ AddAction.fixedBy α g ↔ a ∈ AddAction.fixedBy α g | null | true |
_private.Mathlib.Algebra.Homology.HomotopyCofiber.0.HomologicalComplex.homotopyCofiber.descSigma_ext_iff._simp_1_1 | Mathlib.Algebra.Homology.HomotopyCofiber | ∀ {α : Type u_1} {β : α → Type u_4} {a₁ a₂ : α} {b₁ : β a₁} {b₂ : β a₂}, (⟨a₁, b₁⟩ = ⟨a₂, b₂⟩) = (a₁ = a₂ ∧ b₁ ≍ b₂) | null | false |
_private.Lean.PrettyPrinter.Delaborator.Options.0.Lean.initFn._@.Lean.PrettyPrinter.Delaborator.Options.2604662143._hygCtx._hyg.4 | Lean.PrettyPrinter.Delaborator.Options | IO (Lean.Option Bool) | null | false |
Lean.Meta.Grind.EMatchTheoremConstraint.notDefEq | Lean.Meta.Tactic.Grind.Extension | ℕ → Lean.Meta.Grind.CnstrRHS → Lean.Meta.Grind.EMatchTheoremConstraint | A constraint of the form `lhs =/= rhs`.
The `lhs` is one of the bound variables, and the `rhs` an abstract term that must not be definitionally
equal to a term `t` assigned to `lhs`. | true |
_private.Mathlib.RingTheory.LocalIso.0.Algebra.IsLocalIso.trans._simp_1_4 | Mathlib.RingTheory.LocalIso | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
_private.Mathlib.NumberTheory.LSeries.ZMod.0.ZMod.LFunction_apply_zero_of_even._simp_1_2 | Mathlib.NumberTheory.LSeries.ZMod | ∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True | null | false |
_private.Plausible.Gen.0.Plausible.Gen.runUntil.repeatGen.match_1 | Plausible.Gen | (motive : Option ℕ → Sort u_1) →
(attempts : Option ℕ) → (Unit → motive (some 0)) → ((x : Option ℕ) → motive x) → motive attempts | null | false |
LowerSet.coe_div._simp_2 | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : Preorder α] [inst_2 : IsOrderedMonoid α] (s t : LowerSet α),
↑s / ↑t = ↑(s / t) | null | false |
LieModule.Weight.mk | Mathlib.Algebra.Lie.Weights.Basic | {R : Type u_2} →
{L : Type u_3} →
{M : Type u_4} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : LieAlgebra R L] →
[inst_3 : AddCommGroup M] →
[inst_4 : Module R M] →
[inst_5 : LieRingModule L M] →
[inst_6 : LieModule R L... | null | true |
pinGroup.star_mul_self | Mathlib.LinearAlgebra.CliffordAlgebra.SpinGroup | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{Q : QuadraticForm R M} (x : ↥(pinGroup Q)), star x * x = 1 | null | true |
Lean.Grind.CommRing.instReprMon.repr._sunfold | Init.Grind.Ring.CommSolver | Lean.Grind.CommRing.Mon → ℕ → Std.Format | null | false |
IsCyclotomicExtension.Rat.p_mem_span_zeta_sub_one | Mathlib.NumberTheory.NumberField.Cyclotomic.Ideal | ∀ (p k : ℕ) [hp : Fact (Nat.Prime p)] {K : Type u_1} [inst : Field K] [inst_1 : NumberField K]
[hK : IsCyclotomicExtension {p ^ (k + 1)} ℚ K] {ζ : K} (hζ : IsPrimitiveRoot ζ (p ^ (k + 1))),
↑p ∈ Ideal.span {hζ.toInteger - 1} | null | true |
MeasureTheory.FiniteMeasure.restrict_apply | Mathlib.MeasureTheory.Measure.FiniteMeasure | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] (μ : MeasureTheory.FiniteMeasure Ω) (A : Set Ω) {s : Set Ω},
MeasurableSet s → (μ.restrict A) s = μ (s ∩ A) | null | true |
Rep.FiniteCyclicGroup.groupCohomologyIsoEven._proof_4 | Mathlib.RepresentationTheory.Homological.GroupCohomology.FiniteCyclic | ∀ (i : ℕ) [h₀ : NeZero i], Even i → (ComplexShape.up ℕ).Rel ((ComplexShape.up ℕ).prev i) i | null | false |
AddSubgroup.coe_pathComponentZero | Mathlib.Topology.Connected.PathConnected | ∀ (G : Type u_4) [inst : AddGroup G] [inst_1 : TopologicalSpace G] [inst_2 : IsTopologicalAddGroup G],
↑(AddSubgroup.pathComponentZero G) = pathComponent 0 | null | true |
spectrum.spectralRadius_le_liminf_pow_nnnorm_pow_one_div | Mathlib.Analysis.Normed.Algebra.Spectrum | ∀ (𝕜 : Type u_1) {A : Type u_2} [inst : NormedField 𝕜] [inst_1 : NormedRing A] [inst_2 : NormedAlgebra 𝕜 A]
[CompleteSpace A] (a : A), spectralRadius 𝕜 a ≤ Filter.liminf (fun n => ↑‖a ^ n‖₊ ^ (1 / ↑n)) Filter.atTop | null | true |
NumberField.Ideal.primesOverSpanEquivMonicFactorsMod_symm_apply._proof_1 | Mathlib.NumberTheory.NumberField.Ideal.KummerDedekind | ∀ {p : ℕ} [Fact (Nat.Prime p)], Ideal.span {↑p} ≠ ⊥ | null | false |
ContinuousLinearMap.instAddMonoid._proof_5 | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Basic | ∀ {R₁ : Type u_3} {R₂ : Type u_4} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {M₁ : Type u_1}
[inst_2 : TopologicalSpace M₁] [inst_3 : AddCommMonoid M₁] {M₂ : Type u_2} [inst_4 : TopologicalSpace M₂]
[inst_5 : AddCommMonoid M₂] [inst_6 : Module R₁ M₁] [inst_7 : Module R₂ M₂] [inst_8 : ContinuousAd... | null | false |
_private.Mathlib.CategoryTheory.Limits.Shapes.Countable.0.CategoryTheory.Limits.IsFiltered.sequentialFunctor_final._simp_3 | Mathlib.CategoryTheory.Limits.Shapes.Countable | ∀ {α : Type u} {R : α → α → Prop} (a : α), List.IsChain R [a] = True | null | false |
NumberField.mixedEmbedding.negAt_apply_isComplex | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | ∀ {K : Type u_1} [inst : Field K] {s : Set { w // w.IsReal }} (x : NumberField.mixedEmbedding.mixedSpace K)
(w : { w // w.IsComplex }), ((NumberField.mixedEmbedding.negAt s) x).2 w = x.2 w | null | true |
_private.Mathlib.NumberTheory.ArithmeticFunction.Misc.0.ArithmeticFunction.sum_Ioc_sigma0_eq_sum_div._proof_1_1 | Mathlib.NumberTheory.ArithmeticFunction.Misc | ∀ (N x : ℕ), x ∈ Finset.Ioc 0 N → N / x = if x = 0 then 0 else N / x | null | false |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.Goal.getEqc.go._unsafe_rec | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.Goal → Lean.Expr → Lean.Expr → Array Lean.Expr → Array Lean.Expr | null | false |
CategoryTheory.BraidedCategory.ofCartesianMonoidalCategory._proof_10 | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(X Y Z : C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator X Y Z).hom
(CategoryTheory.CategoryStruct.comp
{
hom :=
Categ... | null | false |
LocalSubring.instPartialOrder._proof_2 | Mathlib.RingTheory.LocalRing.LocalSubring | ∀ {R : Type u_1} [inst : CommRing R], SubringClass (Subring R) R | null | false |
LatticeHom.snd | Mathlib.Order.Hom.Lattice | {α : Type u_2} → {β : Type u_3} → [inst : Lattice α] → [inst_1 : Lattice β] → LatticeHom (α × β) β | Natural projection homomorphism from `α × β` to `β`. | true |
Lean.Linter.MissingDocs.mkHandler | Lean.Linter.MissingDocs | Lean.Name → Lean.ImportM Lean.Linter.MissingDocs.Handler | null | true |
CategoryTheory.ComposableArrows.isoMk₅._proof_14 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {f g : CategoryTheory.ComposableArrows C 5}
(app₀ : f.obj' 0 _proof_450✝ ≅ g.obj' 0 _proof_450✝) (app₁ : f.obj' 1 _proof_451✝ ≅ g.obj' 1 _proof_451✝)
(app₂ : f.obj' 2 _proof_452✝ ≅ g.obj' 2 _proof_452✝) (app₃ : f.obj' 3 _proof_453✝ ≅ g.obj' 3 _proof_453... | null | false |
SimpleGraph.Coloring.sumEquiv | Mathlib.Combinatorics.SimpleGraph.Sum | {V : Type u_3} →
{W : Type u_5} →
{γ : Type u_7} → {G : SimpleGraph V} → {H : SimpleGraph W} → (G ⊕g H).Coloring γ ≃ G.Coloring γ × H.Coloring γ | Bijection between `(G ⊕g H).Coloring γ` and `G.Coloring γ × H.Coloring γ` | true |
Std.Net.AddressFamily.ipv4.sizeOf_spec | Std.Net.Addr | sizeOf Std.Net.AddressFamily.ipv4 = 1 | null | true |
Std.IterM.toArray_filterMap | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α β γ : Type w} {m : Type w → Type w'} [inst : Monad m] [LawfulMonad m] [inst_2 : Std.Iterator α m β]
[Std.Iterators.Finite α m] {f : β → Option γ} (it : Std.IterM m β),
(Std.IterM.filterMap f it).toArray = (fun x => Array.filterMap f x) <$> it.toArray | null | true |
_private.Lean.Data.Iterators.Producers.PersistentHashMap.0.Lean.PersistentHashMap.Node.measure.match_1.eq_2 | Lean.Data.Iterators.Producers.PersistentHashMap | ∀ {α : Type u_1} {β : Type u_2} (motive : Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β) → Sort u_3)
(key : α) (val : β)
(h_1 :
Lean.PersistentHashMap.Entry.entry key val = Lean.PersistentHashMap.Entry.null →
motive Lean.PersistentHashMap.Entry.null)
(h_2 :
(key_1 : α) →
(v... | null | true |
Rep.indResHomEquiv._proof_8 | Mathlib.RepresentationTheory.Induced | ∀ {k : Type u_1} {G : Type u_4} {H : Type u_2} [inst : CommRing k] [inst_1 : Group G] [inst_2 : Group H] (φ : G →* H)
(A : Rep.{max u_3 u_2 u_1, u_1, u_4} k G) (B : Rep.{max u_3 u_2 u_1, u_1, u_2} k H) (x x_1 : Rep.ind φ A ⟶ B),
Rep.ofHom
{ toLinearMap := (Rep.Hom.hom (x + x_1)).toLinearMap ∘ₗ Representation.... | null | false |
Submodule.projection_eq_id_sub_projection | Mathlib.LinearAlgebra.Projection | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {p q : Submodule R E}
(hpq : IsCompl p q), q.projection p ⋯ = LinearMap.id - p.projection q hpq | null | true |
PadicComplex.instRankOneNNRealV._proof_6 | Mathlib.NumberTheory.Padics.Complex | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)], Valued.v.IsNontrivial | null | false |
Nat.nonempty_of_pos_sInf | Mathlib.Order.Lattice.Nat | ∀ {s : Set ℕ}, 0 < sInf s → s.Nonempty | null | true |
_private.Mathlib.Data.Finset.Image.0.Finset.coe_map_subset_range._proof_1_1 | Mathlib.Data.Finset.Image | ∀ {α : Type u_2} {β : Type u_1} (f : α ↪ β) (s : Finset α), ↑(Finset.map f s) ⊆ Set.range ⇑f | null | false |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Transform.0.EisensteinSeries.G2_slash_action._simp_1_2 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Transform | ∀ {α : Type u_1} {a b : α}, (a ∈ {b}) = (a = b) | null | false |
_private.Init.Data.String.Lemmas.Pattern.Char.0.String.Slice.Pattern.Model.Char.revMatchesAt_iff_revMatchesAt_beq._simp_1_1 | Init.Data.String.Lemmas.Pattern.Char | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat] {s : String.Slice} {pos : s.Pos},
String.Slice.Pattern.Model.RevMatchesAt pat pos =
∃ startPos, String.Slice.Pattern.Model.IsLongestRevMatchAt pat startPos pos | null | false |
List.Vector.ofFn | Mathlib.Data.Vector.Defs | {α : Type u_1} → {n : ℕ} → (Fin n → α) → List.Vector α n | Vector of length `n` from a function on `Fin n`. | true |
_private.Mathlib.SetTheory.Cardinal.Pigeonhole.0.Cardinal.le_range_of_union_finset_eq_univ._simp_1_1 | Mathlib.SetTheory.Cardinal.Pigeonhole | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) | null | false |
Subtype.mk_eq_bot_iff | Mathlib.Order.BoundedOrder.Basic | ∀ {α : Type u} {p : α → Prop} [inst : PartialOrder α] [inst_1 : OrderBot α] [inst_2 : OrderBot (Subtype p)],
p ⊥ → ∀ {x : α} (hx : p x), ⟨x, hx⟩ = ⊥ ↔ x = ⊥ | null | true |
Localization.mkHom_surjective | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M}, Function.Surjective ⇑Localization.mkHom | null | true |
MonoidHom.toAdditive._proof_5 | Mathlib.Algebra.Group.TypeTags.Hom | ∀ {α : Type u_2} {β : Type u_1} [inst : MulOneClass α] [inst_1 : MulOneClass β] (f : Additive α →+ Additive β), f 0 = 0 | null | false |
AlgebraicGeometry.PresheafedSpace.restrict_presheaf | Mathlib.Geometry.RingedSpace.PresheafedSpace | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {U : TopCat} (X : AlgebraicGeometry.PresheafedSpace C)
{f : U ⟶ ↑X} (h : Topology.IsOpenEmbedding ⇑(CategoryTheory.ConcreteCategory.hom f)),
(X.restrict h).presheaf = h.functor.op.comp X.presheaf | null | true |
IsLocalRing.finrank_cotangentSpace_eq_zero_iff | Mathlib.RingTheory.Ideal.Cotangent | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsLocalRing R] [IsNoetherianRing R],
Module.finrank (IsLocalRing.ResidueField R) (IsLocalRing.CotangentSpace R) = 0 ↔ IsField R | null | true |
String.Slice.Pos.offset_str_le_offset_endExclusive | Init.Data.String.Basic | ∀ {s : String.Slice} {pos : s.Pos}, pos.str.offset ≤ s.endExclusive.offset | null | true |
Nat.RecursiveIn.left | Mathlib.Computability.RecursiveIn | ∀ {O : Set (ℕ →. ℕ)}, Nat.RecursiveIn O fun n => ↑(some (Nat.unpair n).1) | null | true |
AddGroupSeminormClass.toSeminormedAddGroup.congr_simp | Mathlib.Analysis.Normed.Order.Hom.Ultra | ∀ {F : Type u_1} {α : Type u_2} [inst : FunLike F α ℝ] [inst_1 : AddGroup α] [inst_2 : AddGroupSeminormClass F α ℝ]
(f f_1 : F), f = f_1 → AddGroupSeminormClass.toSeminormedAddGroup f = AddGroupSeminormClass.toSeminormedAddGroup f_1 | null | true |
_private.Mathlib.NumberTheory.LSeries.HurwitzZetaOdd.0.HurwitzZeta.hasSum_int_completedSinZeta._simp_1_1 | Mathlib.NumberTheory.LSeries.HurwitzZetaOdd | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] {a : ℤ}, |↑a| = ↑|a| | null | false |
instFinitePresentation | Mathlib.Algebra.Module.FinitePresentation | ∀ {R : Type u_1} [inst : Ring R], Module.FinitePresentation R R | null | true |
Std.TreeMap.minKey?_eq_some_minKey! | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [inst : Inhabited α],
t.isEmpty = false → t.minKey? = some t.minKey! | null | true |
Lean.Meta.Simp.Arith.Int.ToLinear.State.noConfusion | Lean.Meta.Tactic.Simp.Arith.Int.Basic | {P : Sort u} →
{t t' : Lean.Meta.Simp.Arith.Int.ToLinear.State} →
t = t' → Lean.Meta.Simp.Arith.Int.ToLinear.State.noConfusionType P t t' | null | false |
Std.TreeSet.get?_eq_some_iff | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] {k k' : α},
t.get? k = some k' ↔ ∃ (h : k ∈ t), t.get k h = k' | null | true |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants.base | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | {pat s : String.Slice} →
{needlePos stackPos : String.Pos.Raw} →
String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants✝ pat s needlePos stackPos → s.Pos | The start of the window, as a valid position in `s.` | true |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule.0.sum_trapezoidal_integral_adjacent_intervals._simp_1_1 | Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule | ∀ {α : Type u} [inst : NonUnitalNonAssocRing α] (a b c : α), a * c - b * c = (a - b) * c | null | false |
ENNReal.tsum_biUnion_le | Mathlib.Topology.Algebra.InfiniteSum.ENNReal | ∀ {α : Type u_1} {ι : Type u_4} (f : α → ENNReal) (s : Finset ι) (t : ι → Set α),
∑' (x : ↑(⋃ i ∈ s, t i)), f ↑x ≤ ∑ i ∈ s, ∑' (x : ↑(t i)), f ↑x | null | true |
FirstOrder.Language.LHom.realize_onBoundedFormula | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {L' : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'}
[inst_1 : L'.Structure M] (φ : L →ᴸ L') [φ.IsExpansionOn M] {n : ℕ} (ψ : L.BoundedFormula α n) {v : α → M}
{xs : Fin n → M}, (φ.onBoundedFormula ψ).Realize v xs ↔ ψ.Realize v xs | null | true |
Submodule.singleton_smul | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u} [inst : CommSemiring R] {A : Type v} [inst_1 : CommSemiring A] [inst_2 : Algebra R A] (a : A)
(M : Submodule R A), Set.up {a} • M = Submodule.map (LinearMap.mulLeft R a) M | null | true |
intervalIntegral.intervalIntegrable_log'._simp_1 | Mathlib.Analysis.SpecialFunctions.Integrability.Basic | ∀ {a b : ℝ}, IntervalIntegrable Real.log MeasureTheory.volume a b = True | null | false |
Lean.Server.FileWorker.SemanticTokensState.recOn | Lean.Server.FileWorker.SemanticHighlighting | {motive : Lean.Server.FileWorker.SemanticTokensState → Sort u} →
(t : Lean.Server.FileWorker.SemanticTokensState) → motive { } → motive t | null | false |
_private.Mathlib.NumberTheory.NumberField.Cyclotomic.Three.0.IsCyclotomicExtension.Rat.Three.lambda_dvd_or_dvd_sub_one_or_dvd_add_one._simp_1_2 | Mathlib.NumberTheory.NumberField.Cyclotomic.Three | ∀ {α : Type u_1} {a b : α}, (b ∈ {a}) = (b = a) | null | false |
CategoryTheory.Abelian.SpectralObject.rightHomologyDataShortComplex._proof_11 | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_2} {ι : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) (n₀ n₁ n₂ : ℤ)
(hn₁ : n₀ + 1 = n₁) (hn₂ : n₁ + 1 = ... | null | false |
TensorPower.gmonoid._proof_3 | Mathlib.LinearAlgebra.TensorPower.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(x : GradedMonoid fun i => TensorPower R i M), 1 * x = x | null | false |
_private.Init.Data.String.Lemmas.Order.0.String.Pos.lt_sliceTo_iff._simp_1_2 | Init.Data.String.Lemmas.Order | ∀ {s : String} {p₀ : s.Pos} {p : (s.sliceTo p₀).Pos} {q : s.Pos} {h : q ≤ p₀},
(p₀.sliceTo q h ≤ p) = (q ≤ String.Pos.ofSliceTo p) | null | false |
AddMonoid.End.mulRight | Mathlib.Algebra.Ring.Basic | {R : Type u_1} → [inst : NonUnitalNonAssocSemiring R] → R →+ AddMonoid.End R | The right multiplication map: `(a, b) ↦ b * a`. See also `AddMonoidHom.mulRight`. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.