name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Data.NNReal.Defs.0.Real.toNNReal_le_toNNReal_iff._simp_1_1 | Mathlib.Data.NNReal.Defs | ∀ {r₁ r₂ : NNReal}, (r₁ ≤ r₂) = (↑r₁ ≤ ↑r₂) | null | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.deleteOne.match_1.congr_eq_1._sparseCasesOn_3 | Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas | {α : Type u} →
{motive : List α → Sort u_1} →
(t : List α) →
((head : α) → (tail : List α) → motive (head :: tail)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
TensorProduct.assoc_tensor' | Mathlib.LinearAlgebra.TensorProduct.Associator | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_5} {N : Type u_6} {Q : Type u_8} {S : Type u_9}
[inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid Q] [inst_4 : AddCommMonoid S]
[inst_5 : Module R M] [inst_6 : Module R N] [inst_7 : Module R Q] [inst_8 : Module R S],
TensorProduct.as... | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.denote_blastRotateRight._proof_4 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ} (aig : Std.Sat.AIG α) (target : aig.ShiftTarget w),
∀ idx < w, ¬idx < w - target.distance % w → idx - (w - target.distance % w) < w | null | false |
Algebra.TensorProduct.basis_apply | Mathlib.RingTheory.TensorProduct.Free | ∀ {R : Type u_1} {A : Type u_2} {M : Type uM} {ι : Type uι} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module R M] (b : Module.Basis ι R M) (i : ι),
(Algebra.TensorProduct.basis A b) i = 1 ⊗ₜ[R] b i | null | true |
Std.TreeMap.Raw.insertMany_cons | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} {l : List (α × β)} {k : α} {v : β},
t.insertMany ((k, v) :: l) = (t.insert k v).insertMany l | null | true |
Finset.surjOn_of_injOn_of_card_le | Mathlib.Data.Finset.Card | ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β} (f : α → β),
Set.MapsTo f ↑s ↑t → Set.InjOn f ↑s → t.card ≤ s.card → Set.SurjOn f ↑s ↑t | Given an injective map `f` from a finite set `s` to another finite set `t`, if `t` is no larger
than `s`, then `f` is surjective to `t` when restricted to `s`.
See `Finset.surj_on_of_inj_on_of_card_le` for the version where `f` is a dependent function.
| true |
_private.Mathlib.Combinatorics.SimpleGraph.Extremal.Turan.0.SimpleGraph.not_cliqueFree_of_isTuranMaximal._simp_1_4 | Mathlib.Combinatorics.SimpleGraph.Extremal.Turan | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
_private.Mathlib.Tactic.CancelDenoms.Core.0.Mathlib.Tactic.cancelDenominatorsTarget | Mathlib.Tactic.CancelDenoms.Core | Lean.Elab.Tactic.TacticM Unit | null | true |
Std.ExtDTreeMap.getKey!_erase_self | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {k : α}, (t.erase k).getKey! k = default | null | true |
MvQPF.Fix.ind | Mathlib.Data.QPF.Multivariate.Constructions.Fix | ∀ {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n} (p : MvQPF.Fix F α → Prop),
(∀ (x : F (α ::: MvQPF.Fix F α)), MvFunctor.LiftP (α.PredLast p) x → p (MvQPF.Fix.mk x)) → ∀ (x : MvQPF.Fix F α), p x | null | true |
Fin.val_addNat | Init.Data.Fin.Lemmas | ∀ {n : ℕ} (m : ℕ) (i : Fin n), ↑(i.addNat m) = ↑i + m | null | true |
CategoryTheory.Bicategory.Adj.Hom₂.mk.inj | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | ∀ {B : Type u} {inst : CategoryTheory.Bicategory B} {a b : CategoryTheory.Bicategory.Adj B} {α β : a ⟶ b}
{τl : α.l ⟶ β.l} {τr : β.r ⟶ α.r}
{conjugateEquiv_τl :
autoParam ((CategoryTheory.Bicategory.conjugateEquiv β.adj α.adj) τl = τr)
CategoryTheory.Bicategory.Adj.Hom₂.conjugateEquiv_τl._autoParam}
{τl... | null | true |
HasProd.nat_mul_neg_add_one | Mathlib.Topology.Algebra.InfiniteSum.NatInt | ∀ {M : Type u_1} [inst : CommMonoid M] [inst_1 : TopologicalSpace M] {m : M} {f : ℤ → M},
HasProd f m → HasProd (fun n => f ↑n * f (-(↑n + 1))) m | null | true |
CategoryTheory.OplaxFunctor._sizeOf_inst | Mathlib.CategoryTheory.Bicategory.Functor.Oplax | (B : Type u₁) →
{inst : CategoryTheory.Bicategory B} →
(C : Type u₂) →
{inst_1 : CategoryTheory.Bicategory C} → [SizeOf B] → [SizeOf C] → SizeOf (CategoryTheory.OplaxFunctor B C) | null | false |
List.foldl_nil | Init.Data.List.Basic | ∀ {α : Type u_1} {β : Type u_2} {f : α → β → α} {b : α}, List.foldl f b [] = b | null | true |
DomMulAct.smul_aeeqFun_const | Mathlib.MeasureTheory.Function.AEEqFun.DomAct | ∀ {M : Type u_1} {α : Type u_2} {β : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α}
[inst_1 : TopologicalSpace β] [inst_2 : SMul M α] [inst_3 : MeasurableConstSMul M α]
[inst_4 : MeasureTheory.SMulInvariantMeasure M α μ] (c : Mᵈᵐᵃ) (b : β),
c • MeasureTheory.AEEqFun.const α b = MeasureTheory.A... | null | true |
ListSlice.toArray_toList | Init.Data.Slice.List.Lemmas | ∀ {α : Type u_1} {xs : ListSlice α}, (Std.Slice.toList xs).toArray = Std.Slice.toArray xs | null | true |
dvd_of_mul_right_eq | Mathlib.Algebra.Divisibility.Basic | ∀ {α : Type u_1} [inst : Semigroup α] {a b : α} (c : α), a * c = b → a ∣ b | **Alias** of `Dvd.intro`. | true |
one_le_pow_mul_abs_eval_div | Mathlib.Algebra.Polynomial.DenomsClearable | ∀ {K : Type u_1} [inst : Field K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K] {f : Polynomial ℤ} {a b : ℤ},
0 < b →
Polynomial.eval (↑a / ↑b) (Polynomial.map (algebraMap ℤ K) f) ≠ 0 →
1 ≤ ↑b ^ f.natDegree * |Polynomial.eval (↑a / ↑b) (Polynomial.map (algebraMap ℤ K) f)| | Evaluating a polynomial with integer coefficients at a rational number and clearing
denominators, yields a number greater than or equal to one. The target can be any
`LinearOrderedField K`.
The assumption on `K` could be weakened to `LinearOrderedCommRing` assuming that the
image of the denominator is invertible in `K... | true |
_private.Mathlib.Topology.Instances.EReal.Lemmas.0.EReal.continuousAt_add_top_coe._simp_1_2 | Mathlib.Topology.Instances.EReal.Lemmas | ∀ (x y : ℝ), ↑x + ↑y = ↑(x + y) | null | false |
Std.DHashMap.Internal.AssocList.map | Std.Data.DHashMap.Internal.AssocList.Basic | {α : Type u} →
{β : α → Type v} →
{γ : α → Type w} → ((a : α) → β a → γ a) → Std.DHashMap.Internal.AssocList α β → Std.DHashMap.Internal.AssocList α γ | Internal implementation detail of the hash map | true |
CategoryTheory.Abelian.SpectralObject.E._auto_1 | Mathlib.Algebra.Homology.SpectralObject.Page | Lean.Syntax | null | false |
_private.Mathlib.Algebra.Module.FinitePresentation.0.Module.finitePresentation_of_projective.match_1_1 | Mathlib.Algebra.Module.FinitePresentation | ∀ (R : Type u_1) (M : Type u_2) [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(motive : (∃ n f g, Function.Surjective ⇑f ∧ Function.Injective ⇑g ∧ f ∘ₗ g = LinearMap.id) → Prop)
(x : ∃ n f g, Function.Surjective ⇑f ∧ Function.Injective ⇑g ∧ f ∘ₗ g = LinearMap.id),
(∀ (_n : ℕ) (_f : (Fin _n → R) ... | null | false |
Matroid.IsCircuit | Mathlib.Combinatorics.Matroid.Circuit | {α : Type u_1} → Matroid α → Set α → Prop | `M.IsCircuit C` means that `C` is a minimal dependent set in `M`. | true |
Submodule.IsMinimalPrimaryDecomposition.mem_associatedPrimes | Mathlib.RingTheory.Lasker | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{N : Submodule R M} {t : Finset (Submodule R M)},
N.IsMinimalPrimaryDecomposition t → ∀ {q : Submodule R M}, q ∈ t → (q.colon Set.univ).radical ∈ N.associatedPrimes | null | true |
CategoryTheory.SingleObj.toEnd | Mathlib.CategoryTheory.SingleObj | (M : Type u) → [inst : Monoid M] → M ≃* CategoryTheory.End (CategoryTheory.SingleObj.star M) | The endomorphisms monoid of the only object in `SingleObj M` is equivalent to the original
monoid `M`. | true |
CategoryTheory.Bicategory.toNatTrans_conjugateEquiv | Mathlib.CategoryTheory.Bicategory.Adjunction.Cat | ∀ {C D : CategoryTheory.Cat} {L₁ L₂ : C ⟶ D} {R₁ R₂ : D ⟶ C} (adj₁ : CategoryTheory.Bicategory.Adjunction L₁ R₁)
(adj₂ : CategoryTheory.Bicategory.Adjunction L₂ R₂) (f : L₂ ⟶ L₁),
((CategoryTheory.Bicategory.conjugateEquiv adj₁ adj₂) f).toNatTrans =
(CategoryTheory.conjugateEquiv (CategoryTheory.Adjunction.ofCa... | null | true |
SheafOfModules.Presentation.mapRelations._proof_2 | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_4, u_2} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} [inst_1 : CategoryTheory.HasSheafify J AddCommGrpCat]
[inst_2 : J.WEqualsLocallyBijective AddCommGrpCat]
[inst_3 : J.HasSheafCompose (CategoryTheory.forget₂ RingCat AddCo... | null | false |
Con.subgroup._proof_3 | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} [inst : Group G] (c : Con G), c 1 1 | null | false |
Std.Internal.List.getKey?_minKeyD | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
{l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
l.isEmpty = false →
∀ {fallback : α},
Std.Internal.List.getKey? (Std.Internal.List.minKeyD l fallback) l = some (Std.Internal.List.mi... | null | true |
Subgroup.instMulActionLeftTransversal | Mathlib.GroupTheory.Complement | {G : Type u_1} →
[inst : Group G] →
{H : Subgroup G} →
{F : Type u_2} →
[inst_1 : Group F] → [inst_2 : MulAction F G] → [MulAction.QuotientAction F H] → MulAction F H.LeftTransversal | null | true |
_private.Mathlib.LinearAlgebra.Dimension.Free.0.Module.Free.rank_eq_mk_of_infinite_lt._simp_1_1 | Mathlib.LinearAlgebra.Dimension.Free | ∀ (R : Type u) (M : Type v) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Module.Free R M] [StrongRankCondition R], Cardinal.mk (Module.Free.ChooseBasisIndex R M) = Module.rank R M | null | false |
CategoryTheory.Limits.createsFiniteColimitsLeftOp | Mathlib.CategoryTheory.Limits.Preserves.Creates.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.CreatesFiniteLimits F] → CategoryTheory.Limits.CreatesFiniteColimits F.leftOp | If `F : C ⥤ Dᵒᵖ` creates finite limits, then `F.leftOp : Cᵒᵖ ⥤ D` creates finite
colimits. | true |
Lean.Lsp.CancelParams.mk._flat_ctor | Lean.Data.Lsp.CancelParams | Lean.JsonRpc.RequestID → Lean.Lsp.CancelParams | null | false |
UInt32.ofBitVec_ofFin | Init.Data.UInt.Lemmas | ∀ (n : Fin (2 ^ 32)), { toBitVec := { toFin := n } } = UInt32.ofFin n | null | true |
AddHom.srangeRestrict.eq_1 | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} [inst : Add M] {N : Type u_5} [inst_1 : Add N] (f : M →ₙ+ N),
f.srangeRestrict = f.codRestrict f.srange ⋯ | null | true |
Lean.Grind.AC.Context.noConfusionType | Init.Grind.AC | Sort u_1 → {α : Sort u} → Lean.Grind.AC.Context α → {α' : Sort u} → Lean.Grind.AC.Context α' → Sort u_1 | null | false |
Decidable.and_iff_not_not_or_not | Init.PropLemmas | ∀ {a b : Prop} [Decidable a] [Decidable b], a ∧ b ↔ ¬(¬a ∨ ¬b) | null | true |
String.Slice.Pattern.ToForwardSearcher.DefaultForwardSearcher.ctorIdx | Init.Data.String.Pattern.Basic | {ρ : Type} → {pat : ρ} → {s : String.Slice} → String.Slice.Pattern.ToForwardSearcher.DefaultForwardSearcher pat s → ℕ | null | false |
Set.piecewise | Mathlib.Logic.Function.Basic | {α : Type u} →
{β : α → Sort v} → (s : Set α) → ((i : α) → β i) → ((i : α) → β i) → [(j : α) → Decidable (j ∈ s)] → (i : α) → β i | `s.piecewise f g` is the function equal to `f` on the set `s`, and to `g` on its complement. | true |
ModuleCat.ExtendRestrictScalarsAdj.HomEquiv.fromExtendScalars._proof_4 | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] (f : R →+* S) {X : ModuleCat R}
{Y : ModuleCat S} (g : X ⟶ (ModuleCat.restrictScalars f).obj Y)
(a a_1 : TensorProduct R ↑((ModuleCat.restrictScalars f).obj (ModuleCat.of S S)) ↑X),
(TensorProduct.lift
{ toFun := fun s => ModuleCat.... | null | false |
Turing.TM0.Stmt.noConfusion | Mathlib.Computability.TuringMachine.PostTuringMachine | {P : Sort u} →
{Γ : Type u_1} →
{t : Turing.TM0.Stmt Γ} →
{Γ' : Type u_1} → {t' : Turing.TM0.Stmt Γ'} → Γ = Γ' → t ≍ t' → Turing.TM0.Stmt.noConfusionType P t t' | null | false |
_private.Mathlib.Computability.TuringMachine.Tape.0.Turing.Tape.write_nth.match_1_1 | Mathlib.Computability.TuringMachine.Tape | ∀ {Γ : Type u_1} [inst : Inhabited Γ] (motive : Turing.Tape Γ → ℤ → Prop) (x : Turing.Tape Γ) (x_1 : ℤ),
(∀ (x : Turing.Tape Γ), motive x 0) →
(∀ (x : Turing.Tape Γ) (n : ℕ), motive x (Int.ofNat n.succ)) →
(∀ (x : Turing.Tape Γ) (a : ℕ), motive x (Int.negSucc a)) → motive x x_1 | null | false |
HomologicalComplex₂.ofGradedObject | Mathlib.Algebra.Homology.HomologicalBicomplex | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{I₁ : Type u_2} →
{I₂ : Type u_3} →
(c₁ : ComplexShape I₁) →
(c₂ : ComplexShape I₂) →
(X : CategoryTheory.GradedObject (I₁ × I₂) C) →
... | Constructor for bicomplexes taking as inputs a graded object, horizontal differentials
and vertical differentials satisfying suitable relations. | true |
Lean.Elab.Term.Do.Code._sizeOf_5_eq | Lean.Elab.Do.Legacy | ∀ (x : List (Lean.Elab.Term.Do.AltExpr Lean.Elab.Term.Do.Code)), Lean.Elab.Term.Do.Code._sizeOf_5 x = sizeOf x | null | false |
Std.Async.Selectable.case.injEq | Std.Async.Select | ∀ {α β : Type} (selector : Std.Async.Selector β) (cont : β → Std.Async.Async α) (β_1 : Type)
(selector_1 : Std.Async.Selector β_1) (cont_1 : β_1 → Std.Async.Async α),
({ β := β, selector := selector, cont := cont } = { β := β_1, selector := selector_1, cont := cont_1 }) =
(β = β_1 ∧ selector ≍ selector_1 ∧ cont... | null | true |
ArithmeticFunction.instCommRing._proof_1 | Mathlib.NumberTheory.ArithmeticFunction.Defs | ∀ {R : Type u_1} [inst : CommRing R] (a b : ArithmeticFunction R), a - b = a + -b | null | false |
accPt_iff_frequently | Mathlib.Topology.ClusterPt | ∀ {X : Type u} [inst : TopologicalSpace X] {x : X} {C : Set X},
AccPt x (Filter.principal C) ↔ ∃ᶠ (y : X) in nhds x, y ≠ x ∧ y ∈ C | `x` is an accumulation point of a set `C` iff
there are points near `x` in `C` and different from `x`. | true |
Std.ExtHashMap.mem_map | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {f : α → β → γ} {k : α}, k ∈ Std.ExtHashMap.map f m ↔ k ∈ m | null | true |
_private.Init.Data.SInt.Lemmas.0.Int16.toNatClampNeg_ofNat_of_lt._proof_1_2 | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, n < 2 ^ 15 → ¬-2 ^ 15 ≤ ↑n → False | null | false |
ULift.algebra._proof_4 | Mathlib.Algebra.Algebra.Basic | ∀ {R : Type u_3} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (x y : R),
(↑↑(ULift.ringEquiv.symm.toRingHom.comp (algebraMap R A))).toFun (x + y) =
(↑↑(ULift.ringEquiv.symm.toRingHom.comp (algebraMap R A))).toFun x +
(↑↑(ULift.ringEquiv.symm.toRingHom.comp (algebraMap ... | null | false |
Mathlib.CrossRef.Tag.mk.sizeOf_spec | Mathlib.Tactic.CrossRefAttribute | ∀ (declName : Lean.Name) (database : Mathlib.CrossRef.Database) (tag comment : String),
sizeOf { declName := declName, database := database, tag := tag, comment := comment } =
1 + sizeOf declName + sizeOf database + sizeOf tag + sizeOf comment | null | true |
FirstOrder._aux_Mathlib_ModelTheory_LanguageMap___unexpand_FirstOrder_Language_withConstants_1 | Mathlib.ModelTheory.LanguageMap | Lean.PrettyPrinter.Unexpander | null | false |
_private.Mathlib.RingTheory.Valuation.IsTrivialOn.0.Polynomial.valuation_aeval_monomial_eq_valuation_pow._simp_1_1 | Mathlib.RingTheory.Valuation.IsTrivialOn | ∀ {R : Type u} {a : R} [inst : Semiring R] {n : ℕ}, (Polynomial.monomial n) a = Polynomial.C a * Polynomial.X ^ n | null | false |
CategoryTheory.Functor.ReflectsMonomorphisms | Mathlib.CategoryTheory.Functor.EpiMono | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} → [inst_1 : CategoryTheory.Category.{v₂, u₂} D] → CategoryTheory.Functor C D → Prop | A functor reflects monomorphisms if morphisms that are mapped to monomorphisms are themselves
monomorphisms. | true |
CategoryTheory.Limits.colimit.ι_desc_apply | Mathlib.CategoryTheory.ConcreteCategory.Elementwise | ∀ {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.HasColimit F] (c : CategoryTheory.Limits.Cocone F)
(j : J) {F_1 : C → C → Type uF} {carrier : C → Type w}
{instFunLike : (X Y : C) →... | null | true |
_private.Init.Data.Array.Attach.0.Array.attachWithImpl | Init.Data.Array.Attach | {α : Type u_1} → (xs : Array α) → (P : α → Prop) → (∀ x ∈ xs, P x) → Array { x // P x } | Unsafe implementation of `attachWith`, taking advantage of the fact that the representation of
`Array {x // P x}` is the same as the input `Array α`.
| true |
Lean.Elab.Term.elabOmission | Lean.Elab.BuiltinTerm | Lean.Elab.Term.TermElab | null | true |
Valuation.RankOne.mk | Mathlib.RingTheory.Valuation.RankOne | {R : Type u_1} →
{Γ₀ : Type u_2} →
[inst : Ring R] →
[inst_1 : LinearOrderedCommGroupWithZero Γ₀] →
{v : Valuation R Γ₀} → [toRankLeOne : v.RankLeOne] → [toIsNontrivial : v.IsNontrivial] → v.RankOne | null | true |
CategoryTheory.Limits.CoconeMorphism.inv_hom_id | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} {c d : CategoryTheory.Limits.Cocone F} (f : c ≅ d),
CategoryTheory.CategoryStruct.comp f.inv.hom f.hom.hom = CategoryTheory.CategoryStruct.id d.pt | null | true |
_private.Lean.Environment.0.Lean.saveModuleDataParts._proof_1 | Lean.Environment | ∀ (parts : Array (System.FilePath × Lean.ModuleData)), ∀ i ∈ [:parts.size], i < parts.size | null | false |
_private.Mathlib.Tactic.ClickSuggestions.TryPremises.0.Mathlib.Tactic.ClickSuggestions.Candidates.recOn | Mathlib.Tactic.ClickSuggestions.TryPremises | {motive : Mathlib.Tactic.ClickSuggestions.Candidates✝ → Sort u} →
(t : Mathlib.Tactic.ClickSuggestions.Candidates✝) →
((i : Mathlib.Tactic.ClickSuggestions.RwInfo) →
(arr : Array Mathlib.Tactic.ClickSuggestions.RwLemma) →
motive (Mathlib.Tactic.ClickSuggestions.Candidates.rw✝ i arr)) →
((i... | null | false |
Pi.Function.module | Mathlib.Algebra.Module.Pi | (I : Type u) →
(α : Type u_1) → (β : Type u_2) → [inst : Semiring α] → [inst_1 : AddCommMonoid β] → [Module α β] → Module α (I → β) | A special case of `Pi.module` for non-dependent types. Lean struggles to elaborate
definitions elsewhere in the library without this. | true |
_private.Mathlib.NumberTheory.Bernoulli.0.Bernoulli.sum_pow_filter_eq_faulhaber._simp_1_7 | Mathlib.NumberTheory.Bernoulli | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False | null | false |
IsCompactOpenCovered.empty | Mathlib.Topology.Sets.CompactOpenCovered | ∀ {S : Type u_1} {ι : Type u_2} {X : ι → Type u_3} {f : (i : ι) → X i → S} [inst : (i : ι) → TopologicalSpace (X i)],
IsCompactOpenCovered f ∅ | null | true |
Real.cauchy_intCast | Mathlib.Data.Real.Basic | ∀ (z : ℤ), (↑z).cauchy = ↑z | null | true |
Ideal.sup_height_eq_ringKrullDim | Mathlib.RingTheory.Ideal.Height | ∀ {R : Type u_1} [inst : CommRing R] [Nontrivial R], ↑(⨆ I, ⨆ (_ : I ≠ ⊤), I.height) = ringKrullDim R | In a nontrivial commutative ring `R`, the supremum of heights of all ideals is equal to the
Krull dimension of `R`. | true |
Std.DTreeMap.foldlM_eq_foldlM_keys | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} {δ : Type w} {m : Type w → Type w'}
[inst : Monad m] [LawfulMonad m] {f : δ → α → m δ} {init : δ},
Std.DTreeMap.foldlM (fun d a x => f d a) init t = List.foldlM f init t.keys | null | true |
ExistsAndEq.withExistsElimAlongPathImp._unsafe_rec | Mathlib.Tactic.Simproc.ExistsAndEq | {u : Lean.Level} →
{α : Q(Sort u)} →
{P goal : Q(Prop)} →
Q(«$P») →
{a a' : Q(«$α»)} →
List ExistsAndEq.VarQ →
ExistsAndEq.Path →
List ExistsAndEq.HypQ →
(Q(«$a» = «$a'») → List ExistsAndEq.HypQ → Lean.MetaM Q(«$goal»)) → Lean.MetaM Q(«$goal») | null | false |
map_inv₀ | Mathlib.Algebra.GroupWithZero.Units.Lemmas | ∀ {G₀ : Type u_3} {G₀' : Type u_5} {F : Type u_6} [inst : GroupWithZero G₀] [inst_1 : GroupWithZero G₀']
[inst_2 : FunLike F G₀ G₀'] [MonoidWithZeroHomClass F G₀ G₀'] (f : F) (a : G₀), f a⁻¹ = (f a)⁻¹ | A monoid homomorphism between groups with zeros sending `0` to `0` sends `a⁻¹` to `(f a)⁻¹`. | true |
Commute.self_pow | Mathlib.Algebra.Group.Commute.Defs | ∀ {M : Type u_2} [inst : Monoid M] (a : M) (n : ℕ), Commute a (a ^ n) | null | true |
bilinearIteratedFDerivTwo.eq_1 | Mathlib.Analysis.InnerProductSpace.Laplacian | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] (f : E → F)
(x : E), bilinearIteratedFDerivTwo 𝕜 f x = (fderiv 𝕜 (fderiv 𝕜 f) x).toLinearMap₁₂ | null | true |
Std.TreeMap.get!_union | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α}
[inst : Inhabited β], (t₁ ∪ t₂).get! k = t₂.getD k (t₁.get! k) | null | true |
_private.Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar.0.MeasureTheory.Measure.tendsto_addHaar_inter_smul_zero_of_density_zero_aux2._simp_1_1 | Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar | ∀ {α : Type u_1} [inst : AddGroup α] [inst_1 : LinearOrder α] [AddLeftMono α] {a : α} [AddRightMono α],
(|a| ≤ 0) = (a = 0) | null | false |
IsLocalization.Away.mapₐ.congr_simp | Mathlib.RingTheory.ZariskisMainTheorem | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_5} [inst_1 : CommSemiring A] [inst_2 : Algebra R A] {B : Type u_6}
[inst_3 : CommSemiring B] [inst_4 : Algebra R B] (Aₚ : Type u_7) [inst_5 : CommSemiring Aₚ] [inst_6 : Algebra A Aₚ]
[inst_7 : Algebra R Aₚ] [inst_8 : IsScalarTower R A Aₚ] (Bₚ : Type u_8) [inst_9 ... | null | true |
_private.Lean.Elab.DocString.0.Lean.Doc.instMonadLiftTermElabMDocM.match_1 | Lean.Elab.DocString | (motive : Lean.Doc.State → Sort u_1) →
(x : Lean.Doc.State) →
((scopes : List Lean.Elab.Command.Scope) →
(openDecls : List Lean.OpenDecl) →
(lctx : Lean.LocalContext) →
(localInstances : Lean.LocalInstances) →
(options : Lean.Options) →
motive
... | null | false |
Int16.sub_right_inj._simp_1 | Init.Data.SInt.Lemmas | ∀ {a b : Int16} (c : Int16), (c - a = c - b) = (a = b) | null | false |
RootPairing.rootSpan_eq_top_iff | Mathlib.LinearAlgebra.RootSystem.Finite.Nondegenerate | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Fintype ι] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : Field R] [inst_4 : Module R M] [inst_5 : Module R N] (P : RootPairing ι R M N)
[P.IsAnisotropic], P.rootSpan R = ⊤ ↔ P.corootSpan R = ⊤ | null | true |
Lean.Meta.FunInd.Collector.saveFunInd | Lean.Meta.Tactic.FunIndCollect | Lean.Expr → Lean.Meta.FunIndInfo → Array Lean.Expr → Lean.Meta.FunInd.Collector.M Unit | null | true |
LinearMap.mem_finiteRange_iff_hasFiniteRange | Mathlib.Algebra.Module.LinearMap.FiniteRange | ∀ {K : Type u_1} {V : Type u_2} {V₂ : Type u_4} [inst : CommRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
[inst_3 : AddCommGroup V₂] [inst_4 : Module K V₂] [IsNoetherianRing K] {f : V →ₗ[K] V₂},
f ∈ LinearMap.finiteRange K V V₂ ↔ f.HasFiniteRange | null | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_37 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] (w : α),
[].length + 1 ≤ (List.filter (fun x => decide (x = w)) []).length →
[].length < (List.filter (fun x => decide (x = w)) []).length | null | false |
Lean.InternalExceptionId.toString | Lean.InternalExceptionId | Lean.InternalExceptionId → String | Convert internal exception id into the message "internal exception #<idx>" | true |
CharP.subsemiring | Mathlib.Algebra.CharP.Subring | ∀ (R : Type u) [inst : Semiring R] (p : ℕ) [CharP R p] (S : Subsemiring R), CharP (↥S) p | null | true |
_private.Mathlib.RingTheory.ChainOfDivisors.0.pow_image_of_prime_by_factor_orderIso_dvd._simp_1_1 | Mathlib.RingTheory.ChainOfDivisors | ∀ {M : Type u_1} [inst : Monoid M], 1 = ⊥ | null | false |
Polynomial.isMonicOfDegree_sub_add_two | Mathlib.Algebra.Polynomial.Degree.IsMonicOfDegree | ∀ {R : Type u_1} [inst : Ring R] [Nontrivial R] (a b : R),
(Polynomial.X ^ 2 - Polynomial.C a * Polynomial.X + Polynomial.C b).IsMonicOfDegree 2 | null | true |
Booleanisation.instTop | Mathlib.Order.Booleanisation | {α : Type u_1} → [GeneralizedBooleanAlgebra α] → Top (Booleanisation α) | The top element of `Booleanisation α` is the complement of the bottom element of `α`. | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_316 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
Asymptotics.isLittleO_abs_right | Mathlib.Analysis.Asymptotics.Defs | ∀ {α : Type u_1} {E : Type u_3} [inst : Norm E] {f : α → E} {l : Filter α} {u : α → ℝ},
(f =o[l] fun x => |u x|) ↔ f =o[l] u | null | true |
TopPair.Homotopy._sizeOf_inst | Mathlib.Topology.Category.TopPair | {X Y : TopPair} → (f g : X ⟶ Y) → SizeOf (TopPair.Homotopy f g) | null | false |
_private.Mathlib.Algebra.Order.Antidiag.Pi.0.Finset.finsetCongr_piAntidiag_eq_antidiag._simp_1_1 | Mathlib.Algebra.Order.Antidiag.Pi | ∀ {α : Sort u_1} {β : Sort u_2} (e : α ≃ β) {x : β} {y : α}, (e y = x) = (y = e.symm x) | null | false |
Std.HashMap.getElem!_alter_self | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α] {k : α}
[inst : Inhabited β] {f : Option β → Option β}, (m.alter k f)[k]! = (f m[k]?).get! | null | true |
ContinuousLinearMap.toContinuousAffineMap._proof_2 | Mathlib.Topology.Algebra.ContinuousAffineMap | ∀ {R : Type u_3} {V : Type u_1} {W : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup V] [inst_2 : Module R V]
[inst_3 : TopologicalSpace V] [inst_4 : AddCommGroup W] [inst_5 : Module R W] [inst_6 : TopologicalSpace W]
(f : V →L[R] W), Continuous (↑f).toFun | null | false |
CategoryTheory.Functor.PushoutObjObj.ι_iso_of_iso_left | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | {C₁ : Type u₁} →
{C₂ : Type u₂} →
{C₃ : Type u₃} →
[inst : CategoryTheory.Category.{v₁, u₁} C₁] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C₃] →
{F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)} →
{f₁... | Given a `PushoutObjObj` of `f₁ : Arrow C₁` and `f₂ : Arrow C₂`, a `PushoutObjObj` of `f₁'` and
`f₂ : Arrow C₂`, and an isomorphism `f₁ ≅ f₁'`, this defines an isomorphism of the induced
pushout maps. | true |
CategoryTheory.PreZeroHypercover.interFst._proof_2 | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {S : C} (E : CategoryTheory.PreZeroHypercover S)
(F : CategoryTheory.PreZeroHypercover S)
[inst_1 : ∀ (i : E.I₀) (j : F.I₀), CategoryTheory.Limits.HasPullback (E.f i) (F.f j)] (x : (E.inter F).I₀),
CategoryTheory.Limits.HasPullback (E.f ((Equiv.sigmaE... | null | false |
Dynamics.netEntropyEntourage_le_coverEntropyEntourage | Mathlib.Dynamics.TopologicalEntropy.NetEntropy | ∀ {X : Type u_1} {U : SetRel X X} (T : X → X) (F : Set X),
Dynamics.netEntropyEntourage T F U ≤ Dynamics.coverEntropyEntourage T F U | null | true |
CategoryTheory.PreZeroHypercover.sumInl._proof_2 | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {S : C} (E : CategoryTheory.PreZeroHypercover S)
(F : CategoryTheory.PreZeroHypercover S) (i : E.I₀),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id (E.X i)) ((E.sum F).f (Sum.inl i)) = E.f i | null | false |
_private.Lean.Meta.MethodSpecs.0.Lean.MethodSpecsInfo.rec | Lean.Meta.MethodSpecs | {motive : Lean.MethodSpecsInfo✝ → Sort u} →
((clsName : Lean.Name) →
(privateSpecs : Bool) →
(fieldImpls : Array (Lean.Name × Lean.Name)) →
(thms : Array Lean.MethodSpecTheorem✝) →
motive { clsName := clsName, privateSpecs := privateSpecs, fieldImpls := fieldImpls, thms := thms }) ... | null | false |
Pi.nonUnitalNonAssocSemiring._proof_6 | Mathlib.Algebra.Ring.Pi | ∀ {I : Type u_1} {f : I → Type u_2} [inst : (i : I) → NonUnitalNonAssocSemiring (f i)] (a b : (i : I) → f i),
a + b = b + a | null | false |
CategoryTheory.Limits.Multiequalizer.lift_ι_assoc | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape}
(I : CategoryTheory.Limits.MulticospanIndex J C) [inst_1 : CategoryTheory.Limits.HasMultiequalizer I] (W : C)
(k : (a : J.L) → W ⟶ I.left a)
(h :
∀ (b : J.R),
CategoryTheory.CategoryStruct.comp (k (J.fs... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.