name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
BooleanSubalgebra.topEquiv._proof_1 | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_1} [inst : BooleanAlgebra α] {a b : ↥⊤},
(Equiv.Set.univ α) a ≤ (Equiv.Set.univ α) b ↔ (Equiv.Set.univ α) a ≤ (Equiv.Set.univ α) b | null | false |
_private.Mathlib.Basic.IsEmpty.Basic.0.isEmpty_psigma._simp_1_1 | Mathlib.Basic.IsEmpty.Basic | ∀ {α : Sort u_1}, IsEmpty α = ¬Nonempty α | null | false |
Finset.prod_Iio_add_one_comm | Mathlib.Algebra.Order.BigOperators.Group.LocallyFinite | ∀ {α : Type u_1} {M : Type u_2} [inst : CommMonoid M] [inst_1 : LinearOrder α] [inst_2 : LocallyFiniteOrderBot α]
[inst_3 : Add α] [inst_4 : One α] [SuccAddOrder α] [NoMaxOrder α] (a : α) (f : α → M),
∏ i < a + 1, f i = f a * ∏ i < a, f i | null | true |
NumberField.InfinitePlace.one_le_of_lt_one | Mathlib.NumberTheory.NumberField.InfinitePlace.Basic | ∀ {K : Type u_1} [inst : Field K] [NumberField K] {w : NumberField.InfinitePlace K} {a : NumberField.RingOfIntegers K},
a ≠ 0 → (∀ ⦃z : NumberField.InfinitePlace K⦄, z ≠ w → z ↑a < 1) → 1 ≤ w ↑a | null | true |
CategoryTheory.Core.functorToCore._proof_4 | Mathlib.CategoryTheory.Core | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {G : Type u_4} [inst_1 : CategoryTheory.Groupoid G]
(F : CategoryTheory.Functor G C) {X Y : G} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.Groupoid.inv f)) (F.map f) =
CategoryTheory.CategoryStruct.id { of := F.obj Y }.of | null | false |
Lean.CollectMVars.State.mk._flat_ctor | Lean.Util.CollectMVars | Lean.ExprSet → Array Lean.MVarId → Lean.CollectMVars.State | null | false |
WType.toList._sunfold | Mathlib.Data.W.Constructions | (γ : Type u) → WType (WType.Listβ γ) → List γ | null | false |
Std.TreeMap.getEntryGE | Std.Data.TreeMap.AdditionalOperations | {α : Type u} →
{β : Type v} →
{cmp : α → α → Ordering} →
[Std.TransCmp cmp] → (t : Std.TreeMap α β cmp) → (k : α) → (∃ a ∈ t, (cmp a k).isGE = true) → α × β | Given a proof that such a mapping exists, retrieves the key-value pair with the smallest key that is
greater than or equal to the given key.
| true |
CommAlgCat._mkInternal.injEq | Mathlib.Algebra.Category.CommAlgCat.Basic | ∀ {R : Type u} [inst : CommRing R] (carrier : Type v) [commRing : CommRing carrier] [algebra : Algebra R carrier]
(carrier_1 : Type v) (commRing_1 : CommRing carrier_1) (algebra_1 : Algebra R carrier_1),
({ carrier := carrier, commRing := commRing, algebra := algebra } =
{ carrier := carrier_1, commRing := co... | null | false |
Lean.Compiler.LCNF.JoinPointFinder.FindState.mk.noConfusion | Lean.Compiler.LCNF.JoinPoints | {P : Sort u} →
{candidates candidates' : Std.HashMap Lean.FVarId Lean.Compiler.LCNF.JoinPointFinder.CandidateInfo} →
{ candidates := candidates } = { candidates := candidates' } → (candidates = candidates' → P) → P | null | false |
CategoryTheory.Quotient.linear._proof_2 | Mathlib.CategoryTheory.Quotient.Linear | ∀ (R : Type u_3) {C : Type u_2} [inst : Semiring R] [inst_1 : CategoryTheory.Category.{u_1, u_2} C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C] (r : HomRel C)
[inst_4 : CategoryTheory.Congruence r] (hr : ∀ (a : R) ⦃X Y : C⦄ (f₁ f₂ : X ⟶ Y), r f₁ f₂ → r (a • f₁) (a • f₂))
[inst_5 :... | null | false |
Std.Tactic.BVDecide.BVExpr.Cache.insert.match_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | {aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit} →
(motive : Std.Tactic.BVDecide.BVExpr.Cache aig → Sort u_1) →
(cache : Std.Tactic.BVDecide.BVExpr.Cache aig) →
((map : Std.DHashMap Std.Tactic.BVDecide.BVExpr.Cache.Key fun k => Vector Std.Sat.AIG.Fanin k.w) →
(hbound :
∀ {i : ℕ} (k : St... | null | false |
_private.Mathlib.Tactic.CasesM.0.Mathlib.Tactic.matchPatterns.match_1 | Mathlib.Tactic.CasesM | (motive : Option (Lean.Expr × Array Lean.Expr) → Sort u_1) →
(__do_lift : Option (Lean.Expr × Array Lean.Expr)) →
((fst : Lean.Expr) → motive (some (fst, #[]))) →
((x : Option (Lean.Expr × Array Lean.Expr)) → motive x) → motive __do_lift | null | false |
_private.Lean.Linter.UnusedVariables.0.Lean.Linter.initFn._@.Lean.Linter.UnusedVariables.727354328._hygCtx._hyg.2 | Lean.Linter.UnusedVariables | IO Unit | In pattern (when `linter.unusedVariables.patternVars` is false)
* `def foo := match 0 with | unused => 1`
| false |
Submodule.quotientEquivDirectSum._proof_3 | Mathlib.LinearAlgebra.FreeModule.Finite.Quotient | ∀ {ι : Type u_2} {R : Type u_3} {M : Type u_1} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : IsDomain R] [inst_4 : IsPrincipalIdealRing R] [inst_5 : Finite ι] (F : Type u_4) [inst_6 : CommRing F]
[inst_7 : Algebra F R] [inst_8 : Module F M] [inst_9 : IsScalarTower F R M] (b : Module.... | null | false |
CategoryTheory.Limits.piEquivalenceFunctorDiscrete_functor_comp_lim | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {α : Type w₂} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
[inst_1 : CategoryTheory.Limits.HasProductsOfShape α C],
(CategoryTheory.piEquivalenceFunctorDiscrete α C).functor.comp CategoryTheory.Limits.lim =
CategoryTheory.Limits.Pi.functor α | null | true |
_private.Mathlib.Basic.SetLike.Basic.0.SetLike.delabSubtypeSetLike._sparseCasesOn_1 | Mathlib.Basic.SetLike.Basic | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((deBruijnIndex : ℕ) → motive (Lean.Expr.bvar deBruijnIndex)) → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
ContinuousMap.equivFnOfDiscrete_symm_apply | Mathlib.Topology.ContinuousMap.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : DiscreteTopology α]
(f : α → β), ⇑(ContinuousMap.equivFnOfDiscrete.symm f) = f | null | true |
RootPairing.GeckConstruction.equivLieAlgebra._proof_13 | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Basis | ∀ {K : Type u_1} [inst : Field K] [inst_1 : CharZero K] [inst_2 : IsAlgClosed K] {L : Type u_2} [inst_3 : LieRing L]
[inst_4 : LieAlgebra K L] [inst_5 : FiniteDimensional K L] [inst_6 : LieAlgebra.IsSimple K L] (H : LieSubalgebra K L)
[inst_7 : H.IsCartanSubalgebra] (b : (LieAlgebra.IsKilling.rootSystem H).Base),
... | null | false |
bot_lt_isotypicComponent | Mathlib.RingTheory.SimpleModule.Isotypic | ∀ {R : Type u_2} {M : Type u} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (S : Submodule R M)
[IsSimpleModule R ↥S], ⊥ < isotypicComponent R M ↥S | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.contains_inter._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
_private.Mathlib.Analysis.Calculus.UniformLimitsDeriv.0.hasFDerivAt_of_tendstoLocallyUniformlyOn._simp_1_2 | Mathlib.Analysis.Calculus.UniformLimitsDeriv | ∀ {α : Type u_1} {f : Filter α}, (Set.univ ∈ f) = True | null | false |
alternatingGroup.iwasawaStructure_three | Mathlib.GroupTheory.SpecificGroups.Alternating.Simple | {α : Type u_1} →
[inst : DecidableEq α] →
[inst_1 : Fintype α] → MulAction.IwasawaStructure ↥(alternatingGroup α) ↑(Set.powersetCard α 3) | The Iwasawa structure of `alternatingGroup α` acting on `Set.powersetCard α 3`. | true |
Int.emod_minus_one | Init.Data.Int.DivMod.Lemmas | ∀ (a : ℤ), a % -1 = 0 | null | true |
CategoryTheory.StructuredArrow.mapIso | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{S S' : D} →
{T : CategoryTheory.Functor C D} →
(S ≅ S') → (CategoryTheory.StructuredArrow S T ≌ CategoryTheory.StructuredArrow S' T) | An isomorphism `S ≅ S'` induces an equivalence `StructuredArrow S T ≌ StructuredArrow S' T`. | true |
starL.congr_simp | Mathlib.Topology.Algebra.Module.Star | ∀ (R : Type u_1) {A : Type u_2} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : AddCommMonoid A]
[inst_3 : StarAddMonoid A] [inst_4 : Module R A] [inst_5 : StarModule R A] [inst_6 : TopologicalSpace A]
[inst_7 : ContinuousStar A], starL R = starL R | null | true |
SimpleGraph.isHamiltonian_top_iff._simp_1 | Mathlib.Combinatorics.SimpleGraph.Hamiltonian | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α],
(SimpleGraph.completeGraph α).IsHamiltonian = (Fintype.card α = 1 ∨ 3 ≤ Fintype.card α) | null | false |
npow_one | Mathlib.Algebra.Group.NatPowAssoc | ∀ {M : Type u_1} [inst : MulOneClass M] [inst_1 : Pow M ℕ] [NatPowAssoc M] (x : M), x ^ 1 = x | null | true |
_private.Batteries.Data.AssocList.Basic.0.Batteries.AssocList.foldl.eq_1 | Batteries.Data.AssocList.Basic | ∀ {δ : Type u_1} {α : Type u_2} {β : Type u_3} (f : δ → α → β → δ) (init : δ) (as : Batteries.AssocList α β),
Batteries.AssocList.foldl f init as = (Batteries.AssocList.foldlM (fun d a b => pure (f d a b)) init as).run | null | true |
_private.Lean.Parser.Basic.0.Lean.Parser.checkNoWsBefore._regBuiltin.Lean.Parser.checkNoWsBefore.docString_1 | Lean.Parser.Basic | IO Unit | null | false |
_private.Lean.Elab.Tactic.Conv.Simp.0.Lean.Elab.Tactic.Conv.evalSimp.match_1 | Lean.Elab.Tactic.Conv.Simp | (motive : Lean.Meta.Simp.Result × Lean.Meta.Simp.Stats → Sort u_1) →
(x : Lean.Meta.Simp.Result × Lean.Meta.Simp.Stats) →
((result : Lean.Meta.Simp.Result) → (snd : Lean.Meta.Simp.Stats) → motive (result, snd)) → motive x | null | false |
_private.Mathlib.LinearAlgebra.Dimension.Finite.0.Module.exists_nontrivial_relation_sum_zero_of_finrank_succ_lt_card._simp_1_3 | Mathlib.LinearAlgebra.Dimension.Finite | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a + -b = 0) = (a = b) | null | false |
Equiv.Perm.IsSwap.congr_simp | Mathlib.GroupTheory.Perm.Sign | ∀ {α : Type u_1} {inst : DecidableEq α} [inst_1 : DecidableEq α] (f f_1 : Equiv.Perm α), f = f_1 → f.IsSwap = f_1.IsSwap | null | true |
_private.Mathlib.MeasureTheory.VectorMeasure.Decomposition.Hahn.0.MeasureTheory.SignedMeasure.exists_subset_restrict_nonpos'._simp_1_2 | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Hahn | ∀ {α : Type u} (x : α), (x ∈ ∅) = False | null | false |
Std.DHashMap.Raw.Const.getThenInsertIfNew? | Std.Data.DHashMap.Raw | {α : Type u} →
{β : Type v} →
[BEq α] → [Hashable α] → (Std.DHashMap.Raw α fun x => β) → α → β → Option β × Std.DHashMap.Raw α fun x => β | Equivalent to (but potentially faster than) calling `Const.get?` followed by `insertIfNew`.
Checks whether a key is present in a map, returning the associated value, and inserts a value for
the key if it was not found.
If the returned value is `some v`, then the returned map is unaltered. If it is `none`, then the
re... | true |
_private.Mathlib.Tactic.Linter.Header.0.Mathlib.Linter.Style.Header.headerLinter._proof_1 | Mathlib.Tactic.Linter.Header | ∀ (map : Lean.FileMap), map.source.rawEndPos ≤ map.source.rawEndPos | null | false |
Lean.Parser.Command.declVal.parenthesizer | Lean.Parser.Command | Lean.PrettyPrinter.Parenthesizer | null | true |
EReal.natCast_ne_top._simp_1 | Mathlib.Data.EReal.Basic | ∀ (n : ℕ), (↑n = ⊤) = False | null | false |
instLawfulCommIdentityInt64HOrOfNat | Init.Data.SInt.Bitwise | Std.LawfulCommIdentity (fun x1 x2 => x1 ||| x2) 0 | null | true |
StarAlgHom.prodEquiv._proof_1 | Mathlib.Algebra.Star.StarAlgHom | ∀ {R : Type u_4} {A : Type u_1} {B : Type u_2} {C : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : Star A] [inst_4 : Semiring B] [inst_5 : Algebra R B] [inst_6 : Star B]
[inst_7 : Semiring C] [inst_8 : Algebra R C] [inst_9 : Star C],
Function.LeftInverse (fun f => ((StarA... | null | false |
ProofWidgets.RpcEncodablePacket.«_@».ProofWidgets.Data.Html.2686543190._hygCtx._hyg.1.ctorElimType | ProofWidgets.Data.Html | {motive : ProofWidgets.RpcEncodablePacket✝ → Sort u} → ℕ → Sort (max 1 u) | null | false |
InnerProductGeometry.norm_add_eq_add_norm_of_angle_eq_zero | Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] {x y : V},
InnerProductGeometry.angle x y = 0 → ‖x + y‖ = ‖x‖ + ‖y‖ | If the angle between two vectors is 0, the norm of their sum equals
the sum of their norms. | true |
Ordering.swap | Init.Data.Ord.Basic | Ordering → Ordering | Swaps less-than and greater-than ordering results.
Examples:
* `Ordering.lt.swap = Ordering.gt`
* `Ordering.eq.swap = Ordering.eq`
* `Ordering.gt.swap = Ordering.lt`
| true |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.updateAltImp | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
Lean.Compiler.LCNF.Alt pu →
Array (Lean.Compiler.LCNF.Param pu) → Lean.Compiler.LCNF.Code pu → Lean.Compiler.LCNF.Alt pu | null | true |
Std.DHashMap.Raw.insert | Std.Data.DHashMap.Raw | {α : Type u} → {β : α → Type v} → [BEq α] → [Hashable α] → Std.DHashMap.Raw α β → (a : α) → β a → Std.DHashMap.Raw α β | Inserts the given mapping into the map. If there is already a mapping for the given key, then both
key and value will be replaced.
Note: this replacement behavior is true for `HashMap`, `DHashMap`, `HashMap.Raw` and `DHashMap.Raw`.
The `insert` function on `HashSet` and `HashSet.Raw` behaves differently: it will retur... | true |
Subsemigroup.map_injective_of_injective | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Mul M] [inst_1 : Mul N] {f : M →ₙ* N},
Function.Injective ⇑f → Function.Injective (Subsemigroup.map f) | null | true |
Fin.encodeOrdering | Batteries.Data.Fin.Coding | Ordering → Fin 3 | Encode `Ordering` into `Fin 3`. | true |
_private.Mathlib.RingTheory.Coalgebra.IsFrobenius.0.«_aux_Mathlib_RingTheory_Coalgebra_IsFrobenius___delab_app__private_Mathlib_RingTheory_Coalgebra_IsFrobenius_0_termβ⁻¹_1» | Mathlib.RingTheory.Coalgebra.IsFrobenius | Lean.PrettyPrinter.Delaborator.Delab | Pretty printer defined by `notation3` command. | false |
_private.Mathlib.Topology.Sets.VietorisTopology.0.TopologicalSpace.Compacts.instLocallyCompactSpace._proof_2 | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} [inst : TopologicalSpace α] (L U : Set α) (x : α) (M : Set α),
x ∈ interior M ∧ M ⊆ U ∩ interior L → M ⊆ U | null | false |
CategoryTheory.Limits.preservesLimitsOfSize_of_leftOp | Mathlib.CategoryTheory.Limits.Preserves.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C Dᵒᵖ) [CategoryTheory.Limits.PreservesColimitsOfSize.{w, w', v₁, v₂, u₁, u₂} F.leftOp],
CategoryTheory.Limits.PreservesLimitsOfSize.{w, w', v₁, v₂, u₁, u₂} F | If `F.leftOp : Cᵒᵖ ⥤ D` preserves colimits, then `F : C ⥤ Dᵒᵖ` preserves limits. | true |
FirstOrder.Language.Term.substFunc._sunfold | Mathlib.ModelTheory.Syntax | {L : FirstOrder.Language} →
{L' : FirstOrder.Language} → {α : Type u'} → L.Term α → ({n : ℕ} → L.Functions n → L'.Term (Fin n)) → L'.Term α | null | false |
ZMod.χ₈'_eq_χ₄_mul_χ₈ | Mathlib.NumberTheory.LegendreSymbol.ZModChar | ∀ (a : ZMod 8), ZMod.χ₈' a = ZMod.χ₄ a.cast * ZMod.χ₈ a | The relation between `χ₄`, `χ₈` and `χ₈'` | true |
Std.IterM.mk.inj | Init.Data.Iterators.Basic | ∀ {α : Type w} {m : Type w → Type w'} {β : Type w} {internalState internalState_1 : α},
{ internalState := internalState } = { internalState := internalState_1 } → internalState = internalState_1 | null | true |
_private.Mathlib.Logic.Equiv.Basic.0.Equiv.piCongrLeft'._proof_1 | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_1} {β : Sort u_3} (P : α → Sort u_2) (e : α ≃ β) (f : (a : α) → P a), (fun x => ⋯ ▸ f (e.symm (e x))) = f | null | false |
RingHom.FormallyUnramified.holdsForLocalization | Mathlib.RingTheory.RingHom.Unramified | RingHom.HoldsForLocalization fun {R S} [CommRing R] [CommRing S] => RingHom.FormallyUnramified | null | true |
leftCoset_mem_leftCoset | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : Group α] (s : Subgroup α) {a : α}, a ∈ s → a • ↑s = ↑s | null | true |
Int8.minValue_le_toInt | Init.Data.SInt.Lemmas | ∀ (x : Int8), Int8.minValue.toInt ≤ x.toInt | null | true |
_private.Init.Data.Char.Ordinal.0.Char.lt_iff_ofOrdinal_lt._simp_1_1 | Init.Data.Char.Ordinal | ∀ {α : Type u} [inst : LT α] [inst_1 : LE α] [Std.LawfulOrderLT α] {a b : α}, (a < b) = (a ≤ b ∧ ¬b ≤ a) | null | false |
Continuous.homeoOfEquivCompactToT2 | Mathlib.Topology.Homeomorph.Lemmas | {X : Type u_1} →
{Y : Type u_2} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] → [CompactSpace X] → [T2Space Y] → {f : X ≃ Y} → Continuous ⇑f → X ≃ₜ Y | Continuous equivalences from a compact space to a T2 space are homeomorphisms.
This is not true when T2 is weakened to T1
(see `Continuous.homeoOfEquivCompactToT2.t1_counterexample`). | true |
Filter.EventuallyEq.hasFDerivWithinAt_iff | Mathlib.Analysis.Calculus.FDeriv.Congr | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f₀ f₁ : E → F} {f' : E →L[𝕜] F} {x : E} {s : Set E},
f₀ =ᶠ[nhdsWithin ... | null | true |
_private.Mathlib.Analysis.SumIntegralComparisons.0.sum_mul_Ico_le_integral_of_monotone_antitone._proof_1_6 | Mathlib.Analysis.SumIntegralComparisons | ∀ {a b : ℕ} (i : ℕ), ↑a ≤ ↑i ∧ ↑i + 1 ≤ ↑b → ↑a ∈ Set.Icc ↑a ↑b | null | false |
_private.Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Semisimple.0.RootPairing.GeckConstruction.instIsIrreducible._simp_1 | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Semisimple | ∀ {n : Type u_2} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R] {S : Type w}
[inst_3 : CommRing S] (f : R →+* S) (M : Matrix n n R), (f.mapMatrix M).det = f M.det | null | false |
LaurentSeries.LaurentSeries_coe | Mathlib.RingTheory.LaurentSeries | ∀ (K : Type u_2) [inst : Field K] (x : RatFunc K),
(LaurentSeries.LaurentSeriesPkg K).coe (WithVal.toVal (RatFunc.polynomialValuationX K) x) =
(algebraMap (RatFunc K) (LaurentSeries K)) x | null | true |
Holor.assocRight | Mathlib.Data.Holor | {α : Type} → {ds₁ ds₂ ds₃ : List ℕ} → Holor α (ds₁ ++ ds₂ ++ ds₃) → Holor α (ds₁ ++ (ds₂ ++ ds₃)) | Right associator for `Holor` | true |
isStarProjection_iff' | Mathlib.Algebra.Star.StarProjection | ∀ {R : Type u_1} {p : R} [inst : Mul R] [inst_1 : Star R], IsStarProjection p ↔ p * p = p ∧ star p = p | null | true |
_private.Mathlib.Logic.Equiv.Multiset.0.Denumerable.lower.match_1.eq_1 | Mathlib.Logic.Equiv.Multiset | ∀ (motive : List ℕ → ℕ → Sort u_1) (x : ℕ) (h_1 : (x : ℕ) → motive [] x)
(h_2 : (m : ℕ) → (l : List ℕ) → (n : ℕ) → motive (m :: l) n),
(match [], x with
| [], x => h_1 x
| m :: l, n => h_2 m l n) =
h_1 x | null | true |
PresheafOfModules.epi_of_surjective | Mathlib.Algebra.Category.ModuleCat.Presheaf.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
{M₁ M₂ : PresheafOfModules R} {f : M₁ ⟶ M₂},
(∀ ⦃X : Cᵒᵖ⦄, Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom (f.app X))) → CategoryTheory.Epi f | null | true |
CategoryTheory.Abelian.SpectralObject.coreE₂HomologicalNat | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore EInt
(fun r => ComplexShape.spectralSequenceNat (-r, r - 1)) 2 | The data which allows to construct an `E₂`-homological spectral sequence
indexed by `ℕ × ℕ` from a spectral object indexed by `EInt`. (Note: additional
assumptions on the spectral object are required for the construction of
the spectral sequence from this.) | true |
Interval.mulOneClass._proof_1 | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_1} [inst : CommMonoid α] [inst_1 : Preorder α] [inst_2 : IsOrderedMonoid α] (s : Interval α),
WithBot.map₂ (fun x1 x2 => x1 * x2) (↑1) s = s | null | false |
AddCommMonoidWithOne.mk | Mathlib.Data.Nat.Cast.Defs | {R : Type u_2} → [toAddMonoidWithOne : AddMonoidWithOne R] → (∀ (a b : R), a + b = b + a) → AddCommMonoidWithOne R | null | true |
_private.Init.Data.String.OrderInstances.0.String.Pos.Raw.instTotalLe._simp_9 | Init.Data.String.OrderInstances | ∀ {s : String.Slice} {x y : s.Pos}, (x = y) = (x.offset = y.offset) | null | false |
Graph.edgeSet_ofSimpleGraph | Mathlib.Combinatorics.Graph.Simple | ∀ {α : Type u_1} (G : SimpleGraph α), (Graph.ofSimpleGraph G).edgeSet = G.edgeSet | null | true |
groupHomology.chainsIso₀._proof_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {G : Type u_1}, Subsingleton (Fin 0 → G) | null | false |
VAdd.ctorIdx | Mathlib.Algebra.Notation.Defs | {G : Type u} → {P : Type v} → VAdd G P → ℕ | null | false |
_private.Mathlib.Analysis.Convex.Side.0.Affine.Simplex.sSameSide_affineSpan_faceOpposite_iff.match_1_1 | Mathlib.Analysis.Convex.Side | ∀ {R : Type u_1} [inst : Field R] [inst_1 : LinearOrder R] {n : ℕ} {w₁ w₂ : Fin (n + 1) → R} {i : Fin (n + 1)}
(motive : SignType.sign (w₁ i) = SignType.sign (w₂ i) ∧ w₁ i ≠ 0 → Prop)
(x : SignType.sign (w₁ i) = SignType.sign (w₂ i) ∧ w₁ i ≠ 0),
(∀ (hs : SignType.sign (w₁ i) = SignType.sign (w₂ i)) (h0 : w₁ i ≠ 0... | null | false |
Std.DTreeMap.Internal.Impl.maxEntry?.eq_2 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} (size : ℕ) (k : α) (v : β k) (l : Std.DTreeMap.Internal.Impl α β),
(Std.DTreeMap.Internal.Impl.inner size k v l Std.DTreeMap.Internal.Impl.leaf).maxEntry? = some ⟨k, v⟩ | null | true |
_private.Batteries.Data.List.Lemmas.0.List.findIdxNth_countPBefore_of_lt_length_of_pos._proof_1_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {i : ℕ} {h : i < [].length}, List.findIdxNth p [] (List.countPBefore p [] i) = i | null | false |
Std.Roo._sizeOf_1 | Init.Data.Range.Polymorphic.PRange | {α : Type u} → [SizeOf α] → Std.Roo α → ℕ | null | false |
_private.Mathlib.SetTheory.Cardinal.SchroederBernstein.0.Function.Embedding.total.match_1_3 | Mathlib.SetTheory.Cardinal.SchroederBernstein | ∀ (α : Type u_1) (β : Type u_2)
(motive :
((bif false then ULift.{u_2, u_1} α else ULift.{max u_1 u_2, u_2} β) ↪
bif true then ULift.{u_2, u_1} α else ULift.{max u_1 u_2, u_2} β) →
Prop)
(x :
(bif false then ULift.{u_2, u_1} α else ULift.{max u_1 u_2, u_2} β) ↪
bif true then ULift.{u_2, ... | null | false |
IsPrimitiveRoot.powerBasis_dim | Mathlib.NumberTheory.Cyclotomic.PrimitiveRoots | ∀ {n : ℕ} [inst : NeZero n] (K : Type u) {L : Type v} [inst_1 : Field K] [inst_2 : CommRing L] [inst_3 : IsDomain L]
[inst_4 : Algebra K L] [inst_5 : IsCyclotomicExtension {n} K L] {ζ : L} (hζ : IsPrimitiveRoot ζ n),
(IsPrimitiveRoot.powerBasis K hζ).dim = (minpoly K ζ).natDegree | null | true |
Pi.instCeilDiv._proof_3 | Mathlib.Algebra.Order.Floor.Div | ∀ {ι : Type u_3} {α : Type u_1} {π : ι → Type u_2} [inst : AddCommMonoid α] [inst_1 : PartialOrder α]
[inst_2 : (i : ι) → AddCommMonoid (π i)] [inst_3 : (i : ι) → PartialOrder (π i)]
[inst_4 : (i : ι) → SMulZeroClass α (π i)] [inst_5 : (i : ι) → CeilDiv α (π i)] (_a : α),
0 < _a → ∀ (_f _g : (i : ι) → π i), (∀ (a... | null | false |
Lean.Compiler.LCNF.Simp.CtorInfo._sizeOf_inst | Lean.Compiler.LCNF.Simp.DiscrM | SizeOf Lean.Compiler.LCNF.Simp.CtorInfo | null | false |
FormalMultilinearSeries.congr_simp | Mathlib.Analysis.Analytic.Basic | ∀ (𝕜 : Type u_1) (E : Type u_2) (F : Type u_3) [inst : Semiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [inst_4 : ContinuousAdd E] [inst_5 : ContinuousConstSMul 𝕜 E] [inst_6 : AddCommMonoid F]
[inst_7 : Module 𝕜 F] [inst_8 : TopologicalSpace F] [inst_9 : ContinuousAdd ... | null | true |
Combinatorics.Line.ColorFocused.distinct_colors | Mathlib.Combinatorics.HalesJewett | ∀ {α : Type u_5} {ι : Type u_6} {κ : Type u_7} {C : (ι → Option α) → κ} (self : Combinatorics.Line.ColorFocused C),
(Multiset.map Combinatorics.Line.AlmostMono.color self.lines).Nodup | The proposition that all lines in a color-focused collection of lines have distinct colors. | true |
WittVector.IsPoly₂.comp | Mathlib.RingTheory.WittVector.IsPoly | ∀ {p : ℕ} {h : ⦃R : Type u_2⦄ → [CommRing R] → WittVector p R → WittVector p R → WittVector p R}
{f g : ⦃R : Type u_2⦄ → [CommRing R] → WittVector p R → WittVector p R} [hh : WittVector.IsPoly₂ p h]
[hf : WittVector.IsPoly p f] [hg : WittVector.IsPoly p g], WittVector.IsPoly₂ p fun x _Rcr x_1 y => h (f x_1) (g y) | The composition of polynomial functions is polynomial. | true |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Initialize.0.Lean.Meta.RefinedDiscrTree.ImportFailure.mk._flat_ctor | Mathlib.Lean.Meta.RefinedDiscrTree.Initialize | Lean.Name → Lean.Name → Lean.Exception → Lean.Meta.RefinedDiscrTree.ImportFailure✝ | null | false |
CategoryTheory.Adjunction.commShiftIso_hom_app_counit_app_shift_assoc | Mathlib.CategoryTheory.Shift.Adjunction | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
(adj : F ⊣ G) (A : Type u_3) [inst_2 : AddMonoid A] [inst_3 : CategoryTheory.HasShift C A]
[inst_4 : CategoryTheory.HasShi... | null | true |
Topology.WithUpper | Mathlib.Topology.Order.LowerUpperTopology | Type u_3 → Type u_3 | Type synonym for a preorder equipped with the upper topology. | true |
PFunctor.M.Agree'.recOn | Mathlib.Data.PFunctor.Univariate.M | ∀ {F : PFunctor.{uA, uB}} {motive : (a : ℕ) → (a_1 a_2 : F.M) → PFunctor.M.Agree' a a_1 a_2 → Prop} {a : ℕ}
{a_1 a_2 : F.M} (t : PFunctor.M.Agree' a a_1 a_2),
(∀ (x y : F.M), motive 0 x y ⋯) →
(∀ {n : ℕ} {a : F.A} (x y : F.B a → F.M) {x' y' : F.M} (a_3 : x' = PFunctor.M.mk (PFunctor.Obj.mk a x))
(a_4 : ... | null | false |
Option.merge_none_left | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {f : α → α → α} {b : Option α}, Option.merge f none b = b | null | true |
Prod.instTorsor._proof_1 | Mathlib.Algebra.Torsor.Basic | ∀ {G : Type u_1} {G' : Type u_2} {P : Type u_3} {P' : Type u_4} [inst : Group G] [inst_1 : Group G']
[inst_2 : Torsor G P] [inst_3 : Torsor G' P'] (x x_1 : G × G') (x_2 : P × P'), (x * x_1) • x_2 = x • x_1 • x_2 | null | false |
CategoryTheory.Pi.instBraidedForallEval._proof_2 | Mathlib.CategoryTheory.Pi.Monoidal | ∀ {I : Type u_3} {C : I → Type u_2} [inst : (i : I) → CategoryTheory.Category.{u_1, u_2} (C i)]
[inst_1 : (i : I) → CategoryTheory.MonoidalCategory (C i)] [inst_2 : (i : I) → CategoryTheory.BraidedCategory (C i)]
(i : I) (X Y : (i : I) → C i),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.LaxMonoidal... | null | false |
Aesop.BaseRuleSet.mk.injEq | Aesop.RuleSet | ∀ (normRules : Aesop.Index Aesop.NormRuleInfo) (unsafeRules : Aesop.Index Aesop.UnsafeRuleInfo)
(safeRules : Aesop.Index Aesop.SafeRuleInfo) (unfoldRules : Lean.PHashMap Lean.Name (Option Lean.Name))
(forwardRules : Aesop.ForwardIndex) (forwardRuleNames : Lean.PHashSet Aesop.RuleName)
(rulePatterns : Aesop.RulePa... | null | true |
_private.Mathlib.Util.Notation3.0.Mathlib.Notation3.exprToMatcher.match_12 | Mathlib.Util.Notation3 | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((mvarId : Lean.MVarId) → motive (Lean.Expr.mvar mvarId)) →
((n : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const n us)) →
((u : Lean.Level) → motive (Lean.Expr.sort u)) →
((fvarId : Lean.FVarId) → motive (Lean.Expr.fvar fva... | null | false |
_private.Lean.Parser.Do.0.Lean.Parser.Term.do._regBuiltin.Lean.Parser.Term.do.declRange_3 | Lean.Parser.Do | IO Unit | null | false |
Std.Time.Month.instLawfulEqOrdOffset | Std.Time.Date.Unit.Month | Std.LawfulEqOrd Std.Time.Month.Offset | null | true |
BitVec.instRxcIsAlwaysFinite | Init.Data.Range.Polymorphic.BitVec | ∀ {n : ℕ}, Std.Rxc.IsAlwaysFinite (BitVec n) | null | true |
BddOrd.Iso.mk | Mathlib.Order.Category.BddOrd | {α β : BddOrd} → ↑α.toPartOrd ≃o ↑β.toPartOrd → (α ≅ β) | Constructs an equivalence between bounded orders from an order isomorphism between them. | true |
Lean.Sym.dite_false | Init.Sym.Lemmas | ∀ {α : Sort u} (c : Prop) {inst : Decidable c} (a : c → α) (b : ¬c → α) {ht : ¬c}, dite c a b = b ht | null | true |
_private.Mathlib.CategoryTheory.Bicategory.Span.Basic.0.CategoryTheory.Span.SpanBicat.leftUnitor._proof_1 | Mathlib.CategoryTheory.Bicategory.Span.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {Wₗ Wᵣ : CategoryTheory.MorphismProperty C}
[inst_1 : Wₗ.ContainsIdentities] [inst_2 : Wᵣ.ContainsIdentities] [inst_3 : Wₗ.HasPullbacksAgainst Wᵣ]
[inst_4 : Wₗ.IsStableUnderBaseChangeAgainst Wᵣ] [inst_5 : Wᵣ.IsStableUnderBaseChangeAgainst Wₗ]
[inst_6 ... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.