name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Int8.ofIntLE_bitVecToInt._proof_1 | Init.Data.SInt.Lemmas | ∀ (n : BitVec 8), Int8.minValue.toInt ≤ n.toInt | false |
MeasureTheory.lintegral_comp_eq_lintegral_meas_lt_mul | Mathlib.MeasureTheory.Integral.Layercake | ∀ {α : Type u_1} [inst : MeasurableSpace α] {f : α → ℝ} {g : ℝ → ℝ} (μ : MeasureTheory.Measure α),
0 ≤ᵐ[μ] f →
AEMeasurable f μ →
(∀ t > 0, IntervalIntegrable g MeasureTheory.volume 0 t) →
(∀ᵐ (t : ℝ) ∂MeasureTheory.volume.restrict (Set.Ioi 0), 0 ≤ g t) →
∫⁻ (ω : α), ENNReal.ofReal (∫ (t :... | true |
CategoryTheory.Monad.forget_map | Mathlib.CategoryTheory.Monad.Algebra | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (T : CategoryTheory.Monad C) {X Y : T.Algebra} (f : X ⟶ Y),
T.forget.map f = f.f | true |
LinearMap.range_domRestrict_eq_range_iff | Mathlib.LinearAlgebra.Span.Basic | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_4} {M₂ : Type u_5} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommGroup M] [inst_3 : Module R M] [inst_4 : AddCommGroup M₂] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
[inst_6 : RingHomSurjective τ₁₂] {f : M →ₛₗ[τ₁₂] M₂} {S : Submodule R M},
(f.domRestrict S)... | true |
Lean.Parser.Command.grindPattern.parenthesizer | Lean.Meta.Tactic.Grind.Parser | Lean.PrettyPrinter.Parenthesizer | true |
_private.Mathlib.Order.Interval.Set.Disjoint.0.Set.Ioo_disjoint_Ioo._simp_1_1 | Mathlib.Order.Interval.Set.Disjoint | ∀ {α : Type u} {s t : Set α}, Disjoint s t = (s ∩ t = ∅) | false |
_private.Init.Data.List.Sort.Basic.0.List.merge._unary._proof_2 | Init.Data.List.Sort.Basic | ∀ {α : Type u_1} (x : α) (xs : List α) (y : α) (ys : List α),
(invImage (fun x => PSigma.casesOn x fun xs ys => (xs, ys)) Prod.instWellFoundedRelation).1 ⟨xs, y :: ys⟩
⟨x :: xs, y :: ys⟩ | false |
_private.Mathlib.Data.ENat.Basic.0.ENat.WithBot.lt_add_one_iff._simp_1_2 | Mathlib.Data.ENat.Basic | ∀ {α : Type u_1} [inst : LT α] (a : α), (⊥ < ↑a) = True | false |
RelIso.casesOn | Mathlib.Order.RelIso.Basic | {α : Type u_5} →
{β : Type u_6} →
{r : α → α → Prop} →
{s : β → β → Prop} →
{motive : r ≃r s → Sort u} →
(t : r ≃r s) →
((toEquiv : α ≃ β) →
(map_rel_iff' : ∀ {a b : α}, s (toEquiv a) (toEquiv b) ↔ r a b) →
motive { toEquiv := toEquiv, map_rel_... | false |
TensorProduct.AlgebraTensorModule.rightComm._proof_8 | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ (R : Type u_1) (S : Type u_2) (M : Type u_3) (P : Type u_4) (Q : Type u_5) [inst : CommSemiring R]
[inst_1 : AddCommMonoid M] [inst_2 : Module R M] [inst_3 : AddCommMonoid P] [inst_4 : AddCommMonoid Q]
[inst_5 : Module R Q] [inst_6 : CommSemiring S] [inst_7 : Module S M] [inst_8 : Module S P]
[inst_9 : SMulComm... | false |
Lean.Elab.WF.GuessLex.withUserNames | Lean.Elab.PreDefinition.WF.GuessLex | {α : Type} → Array Lean.Expr → Array Lean.Name → Lean.MetaM α → Lean.MetaM α | true |
Subgroup.coe_square | Mathlib.Algebra.Group.Subgroup.Even | ∀ {G : Type u_1} [inst : CommGroup G], ↑(Subgroup.square G) = {s | IsSquare s} | true |
Lean.Meta.Grind.Arith.Cutsat.instHashableExpr_lean.hash | Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof | Int.Linear.Expr → UInt64 | true |
Aesop.UnfoldRule.mk.injEq | Aesop.Rule | ∀ (decl : Lean.Name) (unfoldThm? : Option Lean.Name) (decl_1 : Lean.Name) (unfoldThm?_1 : Option Lean.Name),
({ decl := decl, unfoldThm? := unfoldThm? } = { decl := decl_1, unfoldThm? := unfoldThm?_1 }) =
(decl = decl_1 ∧ unfoldThm? = unfoldThm?_1) | true |
String.Slice.Pattern.Model.IsValidSearchFrom.matched_of_eq | Init.Data.String.Lemmas.Pattern.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.ForwardPatternModel pat] {s : String.Slice}
{startPos startPos' endPos : s.Pos} {l : List (String.Slice.Pattern.SearchStep s)},
String.Slice.Pattern.Model.IsValidSearchFrom pat endPos l →
String.Slice.Pattern.Model.IsLongestMatchAt pat startPos' endPos →... | true |
EReal.mul_div_left_comm | Mathlib.Data.EReal.Inv | ∀ (a b c : EReal), a * (b / c) = b * (a / c) | true |
LieHom.mk.congr_simp | Mathlib.Algebra.Lie.Basic | ∀ {R : Type u_1} {L : Type u_2} {L' : Type u_3} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : LieRing L'] [inst_4 : LieAlgebra R L'] (toLinearMap toLinearMap_1 : L →ₗ[R] L')
(e_toLinearMap : toLinearMap = toLinearMap_1)
(map_lie' : ∀ {x y : L}, toLinearMap.toFun ⁅x, y⁆ = ⁅toLinearMa... | true |
Std.DHashMap.Internal.Raw₀.erase_equiv_congr | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] (m₁ m₂ : Std.DHashMap.Internal.Raw₀ α β)
[EquivBEq α] [LawfulHashable α],
(↑m₁).WF → (↑m₂).WF → (↑m₁).Equiv ↑m₂ → ∀ {k : α}, (↑(m₁.erase k)).Equiv ↑(m₂.erase k) | true |
Nat.mem_primeFactorsList_mul | Mathlib.Data.Nat.Factors | ∀ {a b : ℕ}, a ≠ 0 → b ≠ 0 → ∀ {p : ℕ}, p ∈ (a * b).primeFactorsList ↔ p ∈ a.primeFactorsList ∨ p ∈ b.primeFactorsList | true |
InnerProductSpace.Core.toNormedAddCommGroupOfTopology | Mathlib.Analysis.InnerProductSpace.Defs | {𝕜 : Type u_1} →
{F : Type u_3} →
[inst : RCLike 𝕜] →
[inst_1 : AddCommGroup F] →
[inst_2 : Module 𝕜 F] →
[cd : InnerProductSpace.Core 𝕜 F] →
[tF : TopologicalSpace F] →
[IsTopologicalAddGroup F] →
[ContinuousConstSMul 𝕜 F] →
... | true |
finsum_sum_comm | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : AddCommMonoid M] (s : Finset β) (f : α → β → M),
(∀ b ∈ s, Function.HasFiniteSupport fun a => f a b) → ∑ᶠ (a : α), ∑ b ∈ s, f a b = ∑ b ∈ s, ∑ᶠ (a : α), f a b | true |
AddCommGrpCat.Colimits.Quot.ι_desc | Mathlib.Algebra.Category.Grp.Colimits | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] (F : CategoryTheory.Functor J AddCommGrpCat)
(c : CategoryTheory.Limits.Cocone F) [inst_1 : DecidableEq J] (j : J) (x : ↑(F.obj j)),
(AddCommGrpCat.Colimits.Quot.desc F c) ((AddCommGrpCat.Colimits.Quot.ι F j) x) =
(CategoryTheory.ConcreteCategory.hom (c.ι... | true |
CategoryTheory.ShortComplex.cyclesFunctorIso._proof_3 | Mathlib.Algebra.Homology.ShortComplex.PreservesHomology | ∀ {C : Type u_4} {D : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] (F : CategoryTheory.Functor C D)
[inst_4 : F.PreservesZeroMorphisms] [CategoryTheory... | false |
Lean.Grind.OrderedAdd.zsmul_le_zsmul | Init.Grind.Ordered.Module | ∀ {M : Type u} [inst : LE M] [inst_1 : Std.IsPreorder M] [inst_2 : Lean.Grind.IntModule M] [Lean.Grind.OrderedAdd M]
{a b : M} {k : ℤ}, 0 ≤ k → a ≤ b → k • a ≤ k • b | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.contains_of_contains_union_of_contains_eq_false_left._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) | false |
Array.mem_flatten_of_mem | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xss : Array (Array α)} {xs : Array α} {a : α}, xs ∈ xss → a ∈ xs → a ∈ xss.flatten | true |
CategoryTheory.ShortComplex.HomologyData.ofIsIsoLeftRightHomologyComparison' | Mathlib.Algebra.Homology.ShortComplex.Homology | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{S : CategoryTheory.ShortComplex C} →
(h₁ : S.LeftHomologyData) →
(h₂ : S.RightHomologyData) →
[CategoryTheory.IsIso (CategoryTheory.ShortComplex.leftRightHomologyCo... | true |
_private.Mathlib.Tactic.Linter.Header.0.Mathlib.Linter.Style.header.collectAtoms._unsafe_rec | Mathlib.Tactic.Linter.Header | Lean.Syntax → Array String | false |
Aesop.Nanos.mk | Aesop.Nanos | ℕ → Aesop.Nanos | true |
AlgebraicGeometry.functionField_isFractionRing_of_isAffineOpen | Mathlib.AlgebraicGeometry.FunctionField | ∀ (X : AlgebraicGeometry.Scheme) [inst : AlgebraicGeometry.IsIntegral X] (U : X.Opens),
AlgebraicGeometry.IsAffineOpen U →
∀ [inst_1 : Nonempty ↥↑U], IsFractionRing ↑(X.presheaf.obj (Opposite.op U)) ↑X.functionField | true |
CategoryTheory.Functor.final_const_terminal | Mathlib.CategoryTheory.Filtered.Final | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[CategoryTheory.IsFiltered C] [inst_3 : CategoryTheory.Limits.HasTerminal D],
((CategoryTheory.Functor.const C).obj (⊤_ D)).Final | true |
CategoryTheory.Sieve.sSup_apply | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} {Ss : Set (CategoryTheory.Sieve X)} {Y : C}
(f : Y ⟶ X), (sSup Ss).arrows f ↔ ∃ S, ∃ (_ : S ∈ Ss), S.arrows f | true |
Int.lt_of_add_lt_add_left | Init.Data.Int.Order | ∀ {a b c : ℤ}, a + b < a + c → b < c | true |
Polynomial.natDegree_eq_card_roots | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : CommRing R] {f : Polynomial R} [inst_1 : IsDomain R], f.Splits → f.natDegree = f.roots.card | true |
_private.Mathlib.RingTheory.Binomial.0.Ring.smeval_ascPochhammer_self_neg.match_1_1 | Mathlib.RingTheory.Binomial | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (a : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x | false |
Algebra.adjoin_singleton_natCast | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ (R : Type uR) (A : Type uA) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (n : ℕ), R[↑n] = ⊥ | true |
WithTop.LinearOrderedAddCommGroup.instLinearOrderedAddCommGroupWithTopOfIsOrderedAddMonoid.match_1 | Mathlib.Algebra.Order.AddGroupWithTop | ∀ {G : Type u_1} [inst : AddCommGroup G] [inst_1 : LinearOrder G] [inst_2 : IsOrderedAddMonoid G]
(motive : (x : WithTop G) → x ≠ ⊤ → Prop) (x : WithTop G) (x_1 : x ≠ ⊤),
(∀ (a : G) (x : ↑a ≠ ⊤), motive (some a) x) → motive x x_1 | false |
ProjectiveSpectrum.zeroLocus_iSup_homogeneousIdeal | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Topology | ∀ {A : Type u_1} {σ : Type u_2} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubmonoidClass σ A] (𝒜 : ℕ → σ)
[inst_3 : GradedRing 𝒜] {γ : Sort u_3} (I : γ → HomogeneousIdeal 𝒜),
ProjectiveSpectrum.zeroLocus 𝒜 ↑(⨆ i, I i) = ⋂ i, ProjectiveSpectrum.zeroLocus 𝒜 ↑(I i) | true |
_private.Lean.Elab.PreDefinition.EqUnfold.0.Lean.Meta.initFn.match_3._@.Lean.Elab.PreDefinition.EqUnfold.1356299382._hygCtx._hyg.2 | Lean.Elab.PreDefinition.EqUnfold | (motive : Lean.Name → Sort u_1) →
(name : Lean.Name) → ((p : Lean.Name) → (s : String) → motive (p.str s)) → ((x : Lean.Name) → motive x) → motive name | false |
CategoryTheory.ComposableArrows.fourδ₁Toδ₀_app_one | Mathlib.CategoryTheory.ComposableArrows.Four | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {i₀ i₁ i₂ i₃ i₄ : C} (f₁ : i₀ ⟶ i₁) (f₂ : i₁ ⟶ i₂)
(f₃ : i₂ ⟶ i₃) (f₄ : i₃ ⟶ i₄) (f₁₂ : i₀ ⟶ i₂) (h₁₂ : CategoryTheory.CategoryStruct.comp f₁ f₂ = f₁₂),
(CategoryTheory.ComposableArrows.fourδ₁Toδ₀ f₁ f₂ f₃ f₄ f₁₂ h₁₂).app 1 =
CategoryTheory.Category... | true |
SimpleGraph.replaceVertex.eq_1 | Mathlib.Combinatorics.SimpleGraph.Operations | ∀ {V : Type u_1} (G : SimpleGraph V) (s t : V) [inst : DecidableEq V],
G.replaceVertex s t =
{ Adj := fun v w => if v = t then if w = t then False else G.Adj s w else if w = t then G.Adj v s else G.Adj v w,
symm := ⋯, loopless := ⋯ } | true |
Vector.ne_and_not_mem_of_not_mem_push | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {a y : α} {xs : Vector α n}, a ∉ xs.push y → a ≠ y ∧ a ∉ xs | true |
_private.Lean.Elab.Tactic.Grind.Lint.0.Lean.Elab.Tactic.Grind.getTheorems | Lean.Elab.Tactic.Grind.Lint | Option (Array Lean.Name) → Bool → Lean.CoreM (List Lean.Name) | true |
Lean.Elab.Term.Do.instInhabitedCode | Lean.Elab.Do.Legacy | Inhabited Lean.Elab.Term.Do.Code | true |
Std.DHashMap.Internal.Raw.Const.get_eq._proof_1 | Std.Data.DHashMap.Internal.Raw | ∀ {α : Type u_1} {β : Type u_2} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α fun x => β} {a : α}
{h : a ∈ m}, 0 < m.buckets.size | false |
List.mapFinIdx.go | Init.Data.List.MapIdx | {α : Type u_1} →
{β : Type u_2} →
(as : List α) →
((i : ℕ) → α → i < as.length → β) → (bs : List α) → (acc : Array β) → bs.length + acc.size = as.length → List β | true |
MonoidHom.injective_codRestrict._simp_2 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {S : Type u_5} [inst_2 : SetLike S N]
[inst_3 : SubmonoidClass S N] (f : M →* N) (s : S) (h : ∀ (x : M), f x ∈ s),
Function.Injective ⇑(f.codRestrict s h) = Function.Injective ⇑f | false |
_private.Aesop.Tree.Data.0.Aesop.GoalOrigin.originalGoalId?._sparseCasesOn_1 | Aesop.Tree.Data | {motive : Aesop.GoalOrigin → Sort u} →
(t : Aesop.GoalOrigin) →
((«from» rep : Aesop.GoalId) → motive (Aesop.GoalOrigin.copied «from» rep)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
OrderIso.isCoatom_iff | Mathlib.Order.Atoms | ∀ {α : Type u_2} {β : Type u_3} [inst : PartialOrder α] [inst_1 : PartialOrder β] [inst_2 : OrderTop α]
[inst_3 : OrderTop β] (f : α ≃o β) (a : α), IsCoatom (f a) ↔ IsCoatom a | true |
Std.DHashMap.Internal.Raw₀.Const.getD_diff_of_contains_right | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.DHashMap.Internal.Raw₀ α fun x => β}
[EquivBEq α] [LawfulHashable α],
(↑m₁).WF →
(↑m₂).WF →
∀ {k : α} {fallback : β},
m₂.contains k = true → Std.DHashMap.Internal.Raw₀.Const.getD (m₁.diff m₂) k fallback = fallback | true |
MeasureTheory.addContent_eq_add_disjointOfDiffUnion_of_subset | Mathlib.MeasureTheory.Measure.AddContent | ∀ {α : Type u_1} {C : Set (Set α)} {s : Set α} {I : Finset (Set α)} {G : Type u_2} [inst : AddCommMonoid G]
{m : MeasureTheory.AddContent G C} (hC : MeasureTheory.IsSetSemiring C) (hs : s ∈ C) (hI : ↑I ⊆ C),
(∀ t ∈ I, t ⊆ s) → (↑I).PairwiseDisjoint id → m s = ∑ i ∈ I, m i + ∑ i ∈ hC.disjointOfDiffUnion hs hI, m i | true |
_private.Mathlib.ModelTheory.Complexity.0.FirstOrder.Language.BoundedFormula.IsAtomic.realize_comp_of_injective._simp_1_4 | Mathlib.ModelTheory.Complexity | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} {l : ℕ} {v : α → M} {xs : Fin l → M}
{k : ℕ} {R : L.Relations k} {ts : Fin k → L.Term (α ⊕ Fin l)},
(R.boundedFormula ts).Realize v xs =
FirstOrder.Language.Structure.RelMap R fun i => FirstOrder.Language.Term.realize (Sum.elim v xs) ... | false |
Std.DTreeMap.Internal.RcoSliceData.mk.injEq | Std.Data.DTreeMap.Internal.Zipper | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] (treeMap : Std.DTreeMap.Internal.Impl α β) (range : Std.Rco α)
(treeMap_1 : Std.DTreeMap.Internal.Impl α β) (range_1 : Std.Rco α),
({ treeMap := treeMap, range := range } = { treeMap := treeMap_1, range := range_1 }) =
(treeMap = treeMap_1 ∧ range = range_1) | true |
Lean.instQuoteCharCharLitKind | Init.Meta.Defs | Lean.Quote Char Lean.charLitKind | true |
Function.FromTypes.uncurry_two_eq_uncurry | Mathlib.Data.Fin.Tuple.Curry | ∀ (p : Fin 2 → Type u) (τ : Type u) (f : Function.FromTypes p τ), f.uncurry = Function.uncurry f ∘ ⇑(piFinTwoEquiv p) | true |
DirectSum.lieAlgebraComponent._proof_1 | Mathlib.Algebra.Lie.DirectSum | ∀ (R : Type u_3) (ι : Type u_2) [inst : CommRing R] (L : ι → Type u_1) [inst_1 : (i : ι) → LieRing (L i)]
[inst_2 : (i : ι) → LieAlgebra R (L i)] (j : ι) {x y : DirectSum ι fun i => L i},
(DirectSum.component R ι L j) ⁅x, y⁆ = ⁅(DirectSum.component R ι L j) x, (DirectSum.component R ι L j) y⁆ | false |
CategoryTheory.PreOneHypercover.instUniqueLMulticospanShapeSigmaOfIsColimit._aux_1 | Mathlib.CategoryTheory.Sites.Hypercover.One | {C : Type u_3} →
[inst : CategoryTheory.Category.{u_2, u_3} C] →
{S : C} →
(E : CategoryTheory.PreOneHypercover S) →
{c : CategoryTheory.Limits.Cofan E.X} →
(hc : CategoryTheory.Limits.IsColimit c) →
{d : CategoryTheory.Limits.Cofan E.Y'} →
(hd : CategoryTheory.Li... | false |
Hindman.FS.below.tail' | Mathlib.Combinatorics.Hindman | ∀ {M : Type u_1} [inst : AddSemigroup M] {motive : (a : Stream' M) → (a_1 : M) → Hindman.FS a a_1 → Prop}
(a : Stream' M) (m : M) (h : Hindman.FS a.tail m), Hindman.FS.below h → motive a.tail m h → Hindman.FS.below ⋯ | true |
_private.Init.Data.Format.Basic.0.Std.Format.SpaceResult.mk | Init.Data.Format.Basic | Bool → Bool → ℕ → Std.Format.SpaceResult✝ | true |
TypeVec.lastFun_appendFun | Mathlib.Data.TypeVec | ∀ {n : ℕ} {α : TypeVec.{u_1} n} {α' : TypeVec.{u_2} n} {β : Type u_1} {β' : Type u_2} (f : α.Arrow α') (g : β → β'),
TypeVec.lastFun (f ::: g) = g | true |
_private.Mathlib.Algebra.Polynomial.FieldDivision.0.Polynomial.remainder_lt_aux | Mathlib.Algebra.Polynomial.FieldDivision | ∀ {R : Type u} [inst : Field R] {q : Polynomial R} (p : Polynomial R), q ≠ 0 → (p.mod q).degree < q.degree | true |
UInt16.xor_eq_zero_iff._simp_1 | Init.Data.UInt.Bitwise | ∀ {a b : UInt16}, (a ^^^ b = 0) = (a = b) | false |
_private.Mathlib.RingTheory.TensorProduct.DirectLimitFG.0.TensorProduct.Algebra.eq_of_fg_of_subtype_eq._simp_1_11 | Mathlib.RingTheory.TensorProduct.DirectLimitFG | ∀ {α : Type u} {s t : Set α}, (t ⊆ s ∪ t) = True | false |
CategoryTheory.OverPresheafAux.OverArrows.yonedaArrow_val | Mathlib.CategoryTheory.Comma.Presheaf.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} {Y : C}
{η : CategoryTheory.yoneda.obj Y ⟶ A} {X : C} {s : CategoryTheory.yoneda.obj X ⟶ A} {f : X ⟶ Y}
(hf : CategoryTheory.CategoryStruct.comp (CategoryTheory.yoneda.map f) η = s),
(CategoryTheory.OverPresheafAux.... | true |
SNum._aux_Mathlib_Data_Num_Bitwise___unexpand_SNum_bit_1 | Mathlib.Data.Num.Bitwise | Lean.PrettyPrinter.Unexpander | false |
IO.instLTTaskState | Init.System.IO | LT IO.TaskState | true |
Lean.Lsp.SnippetString.noConfusion | Lean.Data.Lsp.Basic | {P : Sort u} → {t t' : Lean.Lsp.SnippetString} → t = t' → Lean.Lsp.SnippetString.noConfusionType P t t' | false |
Aesop.NormM.Context.rec | Aesop.Search.Expansion.Norm | {motive : Aesop.NormM.Context → Sort u} →
((options : Aesop.Options') →
(ruleSet : Aesop.LocalRuleSet) →
(normSimpContext : Aesop.NormSimpContext) →
motive { options := options, ruleSet := ruleSet, normSimpContext := normSimpContext }) →
(t : Aesop.NormM.Context) → motive t | false |
Continuous.cexp | Mathlib.Analysis.SpecialFunctions.Exp | ∀ {α : Type u_1} [inst : TopologicalSpace α] {f : α → ℂ}, Continuous f → Continuous fun y => Complex.exp (f y) | true |
HomologicalComplex.hasExactColimitsOfShape | Mathlib.Algebra.Homology.GrothendieckAbelian | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] {ι : Type t} (c : ComplexShape ι)
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (J : Type w) [inst_2 : CategoryTheory.Category.{w', w} J]
[CategoryTheory.Limits.HasFiniteLimits C] [inst_4 : CategoryTheory.Limits.HasColimitsOfShape J C]
[CategoryTheory... | true |
Lean.Meta.DiscrTree.Key.arrow | Lean.Meta.DiscrTree.Types | Lean.Meta.DiscrTree.Key | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.le_two_mul_toInt._proof_1_2 | Init.Data.BitVec.Lemmas | ∀ {x : BitVec 0}, (¬-2 ^ 0 ≤ 2 * if 2 * x.toNat < 2 ^ 0 then ↑x.toNat else ↑x.toNat - ↑(2 ^ 0)) → False | false |
IsRightUniformGroup.mk._flat_ctor | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ {G : Type u_7} [inst : UniformSpace G] [inst_1 : Group G],
(Continuous fun p => p.1 * p.2) →
(Continuous fun a => a⁻¹) → uniformity G = Filter.comap (fun x => x.2 * x.1⁻¹) (nhds 1) → IsRightUniformGroup G | false |
Language.reverse_zero | Mathlib.Computability.Language | ∀ {α : Type u_1}, Language.reverse 0 = 0 | true |
Nat.add_choose | Mathlib.Data.Nat.Choose.Basic | ∀ (i j : ℕ), (i + j).choose j = (i + j).factorial / (i.factorial * j.factorial) | true |
CategoryTheory.Functor.FullyFaithful.preimage | Mathlib.CategoryTheory.Functor.FullyFaithful | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} → F.FullyFaithful → {X Y : C} → (F.obj X ⟶ F.obj Y) → (X ⟶ Y) | true |
AlgebraicGeometry.HasRingHomProperty.of_source_openCover | Mathlib.AlgebraicGeometry.Morphisms.RingHomProperties | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme}
{Q : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop}
[AlgebraicGeometry.HasRingHomProperty P Q] {X Y : AlgebraicGeometry.Scheme} {f : X ⟶ Y} [AlgebraicGeometry.IsAffine Y]
(𝒰 : X.OpenCover) [∀ (i : 𝒰.I₀), Algebraic... | true |
_private.Init.Grind.Ring.Basic.0.Lean.Grind.Ring.intCast_add._proof_1_6 | Init.Grind.Ring.Basic | ∀ (x y : ℕ), y ≥ x + 1 → ¬-↑(x + 1) + ↑y = ↑(y - (x + 1)) → False | false |
Lean.Elab.Tactic.Doc.TacticDoc._sizeOf_inst | Lean.Elab.Tactic.Doc | SizeOf Lean.Elab.Tactic.Doc.TacticDoc | false |
GaloisInsertion.choice_eq | Mathlib.Order.GaloisConnection.Defs | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] {l : α → β} {u : β → α}
(self : GaloisInsertion l u) (a : α) (h : u (l a) ≤ a), self.choice a h = l a | true |
PrimeSpectrum.zeroLocusEquivIrreducibleCloseds | Mathlib.RingTheory.Spectrum.Prime.Topology | {R : Type u} →
[inst : CommSemiring R] →
(I : Set R) → ↑(PrimeSpectrum.zeroLocus I) ≃o (TopologicalSpace.IrreducibleCloseds ↑(PrimeSpectrum.zeroLocus I))ᵒᵈ | true |
CategoryTheory.Abelian.SpectralObject.cokernelSequenceCyclesEIso_inv_τ₂ | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [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₁ : autoParam (n₀ + 1 = n₁) Categ... | true |
Units.instStarMul._proof_4 | Mathlib.Algebra.Star.Basic | ∀ {R : Type u_1} [inst : Monoid R] [inst_1 : StarMul R] (x : Rˣ),
star ↑{ val := star ↑x, inv := star ↑x⁻¹, val_inv := ⋯, inv_val := ⋯ }⁻¹ *
star ↑{ val := star ↑x, inv := star ↑x⁻¹, val_inv := ⋯, inv_val := ⋯ } =
1 | false |
Lean.Parser.Term.noImplicitLambda._regBuiltin.Lean.Parser.Term.noImplicitLambda_1 | Lean.Parser.Term | IO Unit | false |
_private.Mathlib.Algebra.Homology.HomotopyCategory.MappingCone.0.CochainComplex.mappingCone.fst._proof_3 | Mathlib.Algebra.Homology.HomotopyCategory.MappingCone | ∀ (p : ℤ), p + 2 = p + 2 | false |
Orthonormal.basisTensorProduct | Mathlib.Analysis.InnerProductSpace.TensorProduct | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : InnerProductSpace 𝕜 F] {ι₁ : Type u_6}
{ι₂ : Type u_7} {b₁ : Module.Basis ι₁ 𝕜 E} {b₂ : Module.Basis ι₂ 𝕜 F},
Orthonormal 𝕜 ⇑b₁ → Ortho... | true |
instCoeTCBiheytingHomOfBiheytingHomClass._proof_3 | Mathlib.Order.Heyting.Hom | ∀ {F : Type u_2} {α : Type u_3} {β : Type u_1} [inst : FunLike F α β] [inst_1 : BiheytingAlgebra α]
[inst_2 : BiheytingAlgebra β] [BiheytingHomClass F α β] (f : F) (a b : α), f (a ⇨ b) = f a ⇨ f b | false |
HomologicalComplex₂.total.map | Mathlib.Algebra.Homology.TotalComplex | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{I₁ : Type u_2} →
{I₂ : Type u_3} →
{I₁₂ : Type u_4} →
{c₁ : ComplexShape I₁} →
{c₂ : ComplexShape I₂} →
{K L : HomologicalComplex₂ C c₁ c₂} ... | true |
CategoryTheory.ChosenPullbacksAlong.cartesianMonoidalCategorySnd._proof_6 | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(X Y : C) {X_1 Y_1 Z : CategoryTheory.Over Y} (f : X_1 ⟶ Y_1) (g : Y_1 ⟶ Z),
CategoryTheory.Over.homMk
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft X (CategoryTheory.CategoryStruct.comp f... | false |
Height.logHeight_fun_mul_eq | Mathlib.NumberTheory.Height.Basic | ∀ {K : Type u_1} [inst : Field K] [inst_1 : Height.AdmissibleAbsValues K] {ι : Type u_2} {ι' : Type u_3} [Finite ι]
[Finite ι'] {x : ι → K},
x ≠ 0 → ∀ {y : ι' → K}, y ≠ 0 → (Height.logHeight fun a => x a.1 * y a.2) = Height.logHeight x + Height.logHeight y | true |
_private.Mathlib.NumberTheory.Rayleigh.0.Beatty.no_collision.match_1_3 | Mathlib.NumberTheory.Rayleigh | ∀ {s : ℝ} ⦃j : ℤ⦄ (motive : j ∈ {x | ∃ k, beattySeq' s k = x} → Prop) (h : j ∈ {x | ∃ k, beattySeq' s k = x}),
(∀ (m : ℤ) (h₂ : beattySeq' s m = j), motive ⋯) → motive h | false |
Std.PRange.Nat.size_Rio | Init.Data.Range.Polymorphic.NatLemmas | ∀ {b : ℕ}, (*...b).size = b | true |
PUnit.normedCommRing._proof_2 | Mathlib.Analysis.Normed.Ring.Basic | ∀ (a b : PUnit.{u_1 + 1}), a + b = b + a | false |
SSet.horn₂₂.isPushout | Mathlib.AlgebraicTopology.SimplicialSet.HornColimits | CategoryTheory.IsPushout (SSet.stdSimplex.δ 0) (SSet.stdSimplex.δ 0) SSet.horn₂₂.ι₀₂ SSet.horn₂₂.ι₁₂ | true |
MeasureTheory.ComplexMeasure.re | Mathlib.MeasureTheory.Measure.Complex | {α : Type u_1} → {m : MeasurableSpace α} → MeasureTheory.ComplexMeasure α →ₗ[ℝ] MeasureTheory.SignedMeasure α | true |
MonCat.Colimits.coconeMorphism._proof_1 | Mathlib.Algebra.Category.MonCat.Colimits | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} J] (F : CategoryTheory.Functor J MonCat) (j : J),
Quot.mk (⇑(MonCat.Colimits.colimitSetoid F)) (MonCat.Colimits.Prequotient.of j 1) =
Quot.mk (⇑(MonCat.Colimits.colimitSetoid F)) MonCat.Colimits.Prequotient.one | false |
Qq.Impl.ExprBackSubstResult | Qq.Macro | Type | true |
Besicovitch.TauPackage.iUnionUpTo.eq_1 | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u_1} [inst : MetricSpace α] {β : Type u} [inst_1 : Nonempty β] (p : Besicovitch.TauPackage β α)
(i : Ordinal.{u}), p.iUnionUpTo i = ⋃ j, Metric.ball (p.c (p.index ↑j)) (p.r (p.index ↑j)) | true |
_private.Mathlib.LinearAlgebra.Semisimple.0.Module.End.IsSemisimple.of_mem_adjoin_pair._simp_1_2 | Mathlib.LinearAlgebra.Semisimple | ∀ {R : Type u_1} {y : R} [inst : CommSemiring R], (Ideal.span {y}).IsRadical = IsRadical y | false |
ProbabilityTheory.Kernel.instIsFiniteKernelSectROfProd | Mathlib.Probability.Kernel.Composition.MapComap | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4}
{mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel (α × β) γ) (a : α) [ProbabilityTheory.IsFiniteKernel κ],
ProbabilityTheory.IsFiniteKernel (κ.sectR a) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.