name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.instInhabitedNoConfusionInfo.default | Lean.AuxRecursor | Lean.NoConfusionInfo | true |
_private.Mathlib.Tactic.NormNum.Irrational.0.Tactic.NormNum.evalIrrationalRpow._proof_1 | Mathlib.Tactic.NormNum.Irrational | ∀ (gy : Q(ℕ)), «$gy» =Q 1 | false |
_private.Mathlib.Analysis.Calculus.ContDiff.Operations.0.ContDiff.div._simp_1_1 | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{n : WithTop ℕ∞}, ContDiff 𝕜 n f = ∀ (x : E), ContDiffAt 𝕜 n f x | false |
MulAction.smul_zpow_movedBy_eq_of_commute | Mathlib.GroupTheory.GroupAction.FixedPoints | ∀ {α : Type u_1} {G : Type u_2} [inst : Group G] [inst_1 : MulAction G α] {g h : G},
Commute g h → ∀ (j : ℤ), h ^ j • (MulAction.fixedBy α g)ᶜ = (MulAction.fixedBy α g)ᶜ | true |
instAddRightCancelSemigroupColex | Mathlib.Algebra.Order.Group.Synonym | {α : Type u_1} → [h : AddRightCancelSemigroup α] → AddRightCancelSemigroup (Colex α) | true |
_private.Mathlib.Algebra.Group.Submonoid.Operations.0.Submonoid.pi_empty._simp_1_1 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {ι : Type u_4} {M : ι → Type u_5} [inst : (i : ι) → MulOneClass (M i)] (I : Set ι) {S : (i : ι) → Submonoid (M i)}
{p : (i : ι) → M i}, (p ∈ Submonoid.pi I S) = ∀ i ∈ I, p i ∈ S i | false |
Std.HashMap.ofList_cons | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {k : α} {v : β} {tl : List (α × β)},
Std.HashMap.ofList ((k, v) :: tl) = (∅.insert k v).insertMany tl | true |
Lean.Meta.Grind.AC.DiseqCnstrProof.simp_ac.sizeOf_spec | Lean.Meta.Tactic.Grind.AC.Types | ∀ (lhs : Bool) (s : Lean.Grind.AC.Seq) (c₁ : Lean.Meta.Grind.AC.EqCnstr) (c₂ : Lean.Meta.Grind.AC.DiseqCnstr),
sizeOf (Lean.Meta.Grind.AC.DiseqCnstrProof.simp_ac lhs s c₁ c₂) = 1 + sizeOf lhs + sizeOf s + sizeOf c₁ + sizeOf c₂ | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastAdd.atLeastTwo_eq_halfAdder | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add | ∀ (lhsBit rhsBit carry : Bool), lhsBit.atLeastTwo rhsBit carry = ((lhsBit ^^ rhsBit) && carry || lhsBit && rhsBit) | true |
BoundedContinuousFunction.mem_charPoly | Mathlib.Analysis.Fourier.BoundedContinuousFunctionChar | ∀ {V : Type u_1} {W : Type u_2} [inst : AddCommGroup V] [inst_1 : Module ℝ V] [inst_2 : TopologicalSpace V]
[inst_3 : AddCommGroup W] [inst_4 : Module ℝ W] [inst_5 : TopologicalSpace W] {e : AddChar ℝ Circle}
{L : V →ₗ[ℝ] W →ₗ[ℝ] ℝ} {he : Continuous ⇑e} {hL : Continuous fun p => (L p.1) p.2}
(f : BoundedContinuou... | true |
OreLocalization.instSemiring._proof_2 | Mathlib.RingTheory.OreLocalization.Ring | ∀ {R : Type u_1} [inst : Semiring R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S] (n : ℕ),
(n + 1).unaryCast = n.unaryCast + 1 | false |
_private.Mathlib.Topology.Connected.Clopen.0.isPreconnected_iff_subset_of_disjoint._simp_1_1 | Mathlib.Topology.Connected.Clopen | ∀ {α : Type u} {s t : Set α}, (¬s ⊆ t) = ∃ a ∈ s, a ∉ t | false |
MeasureTheory.Measure.pi_Ioc_ae_eq_pi_Icc | Mathlib.MeasureTheory.Constructions.Pi | ∀ {ι : Type u_1} {α : ι → Type u_3} [inst : Fintype ι] [inst_1 : (i : ι) → MeasurableSpace (α i)]
{μ : (i : ι) → MeasureTheory.Measure (α i)} [∀ (i : ι), MeasureTheory.SigmaFinite (μ i)]
[inst_3 : (i : ι) → PartialOrder (α i)] [∀ (i : ι), MeasureTheory.NoAtoms (μ i)] {s : Set ι} {f g : (i : ι) → α i},
(s.pi fun i... | true |
Hyperreal.isSt_iff | Mathlib.Analysis.Real.Hyperreal | ∀ {x : ℝ*} {r : ℝ}, x.IsSt r ↔ 0 ≤ ArchimedeanClass.mk x ∧ ArchimedeanClass.stdPart x = r | true |
Lean.Meta.Grind.instBEqCongrKey._private_1 | Lean.Meta.Tactic.Grind.Types | {enodeMap : Lean.Meta.Grind.ENodeMap} → Lean.Meta.Grind.CongrKey enodeMap → Lean.Meta.Grind.CongrKey enodeMap → Bool | false |
ContinuousAffineEquiv.symm_apply_eq | Mathlib.Topology.Algebra.ContinuousAffineEquiv | ∀ {k : Type u_1} {P₁ : Type u_2} {P₂ : Type u_3} {V₁ : Type u_6} {V₂ : Type u_7} [inst : Ring k]
[inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁] [inst_3 : AddTorsor V₁ P₁] [inst_4 : TopologicalSpace P₁]
[inst_5 : AddCommGroup V₂] [inst_6 : Module k V₂] [inst_7 : AddTorsor V₂ P₂] [inst_8 : TopologicalSpace P₂]
(... | true |
_private.Std.Data.HashSet.RawLemmas.0.Std.HashSet.Raw.Equiv.symm.match_1_1 | Std.Data.HashSet.RawLemmas | ∀ {α : Type u_1} {m₁ m₂ : Std.HashSet.Raw α} (motive : m₁.Equiv m₂ → Prop) (x : m₁.Equiv m₂),
(∀ (h : m₁.inner.Equiv m₂.inner), motive ⋯) → motive x | false |
_private.Init.Data.List.MinMaxIdx.0.List.maxIdxOn_eq_zero_iff._simp_1_1 | Init.Data.List.MinMaxIdx | ∀ {α : Type u_1} {le : LE α} {a b : α}, (a ≤ b) = (b ≤ a) | false |
Quiver.Path.vertices_comp_get_length_eq._auto_1 | Mathlib.Combinatorics.Quiver.Path.Vertices | Lean.Syntax | false |
Std.HashSet.Equiv.inter_right | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ m₃ : Std.HashSet α} [EquivBEq α] [LawfulHashable α],
m₂.Equiv m₃ → (m₁ ∩ m₂).Equiv (m₁ ∩ m₃) | true |
DirectLimit.instAddGroup._proof_12 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : (i : ι) → AddGroup (G i)] [∀ (i j : ι) (h : i ≤ j), AddMonoidHomClass (T h) (G i) (G j)] (n : ℕ) (x x_1 : ι)
(... | false |
Ordinal.type_pUnit | Mathlib.SetTheory.Ordinal.Basic | Ordinal.type emptyRelation = 1 | true |
_private.Lean.Compiler.LCNF.CompatibleTypes.0.Lean.Compiler.LCNF.InferType.Pure.compatibleTypesFull._sparseCasesOn_6 | Lean.Compiler.LCNF.CompatibleTypes | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
((data : Lean.MData) → (expr : Lean.Expr) → motive (Lean.Expr.mdata data expr))... | false |
Equicontinuous | Mathlib.Topology.UniformSpace.Equicontinuity | {ι : Type u_1} →
{X : Type u_3} → {α : Type u_6} → [tX : TopologicalSpace X] → [uα : UniformSpace α] → (ι → X → α) → Prop | true |
SimpleGraph.binomialRandom_one | Mathlib.Probability.Combinatorics.BinomialRandomGraph.Defs | ∀ (V : Type u_1) [Countable V], SimpleGraph.binomialRandom V 1 = MeasureTheory.Measure.dirac ⊤ | true |
CommRing.directSumGCommRing | Mathlib.Algebra.DirectSum.Ring | (ι : Type u_1) → {R : Type u_2} → [inst : AddCommMonoid ι] → [inst_1 : CommRing R] → DirectSum.GCommRing fun x => R | true |
Std.Packages.LinearOrderOfOrdArgs.min_eq | Init.Data.Order.PackageFactories | ∀ {α : Type u} (self : Std.Packages.LinearOrderOfOrdArgs α),
let this := self.ord;
let this_1 := self.le;
let this_2 := self.min;
have this_3 := ⋯;
∀ (a b : α), a ⊓ b = if (compare a b).isLE = true then a else b | true |
CategoryTheory.MorphismProperty.Comma.mapRightEq_hom_app_right | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {A : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} A] {B : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] {T : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} T]
(L : CategoryTheory.Functor A T) {P : CategoryTheory.MorphismProperty T} {Q : CategoryTheory.MorphismProperty A}
{W : Categor... | true |
CochainComplex.HomComplex.Cocycle.coe_sub | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
{F G : CochainComplex C ℤ} {n : ℤ} (z₁ z₂ : CochainComplex.HomComplex.Cocycle F G n), ↑(z₁ - z₂) = ↑z₁ - ↑z₂ | true |
Perfection.quotientMulEquiv._proof_5 | Mathlib.RingTheory.Teichmuller | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)] {R : Type u_1} [inst_1 : CommRing R] (I : Ideal R) [inst_2 : CharP (R ⧸ I) p]
[inst_3 : IsAdicComplete I R],
(Perfection.liftMonoidHom p (Perfection (R ⧸ I) p) (R ⧸ I)).symm
((Perfection.mapMonoidHom p ↑(Ideal.Quotient.mk I)).comp
((Perfection.liftMonoidHom p (Per... | false |
toPrev.eq_1 | Mathlib.Algebra.Homology.BifunctorHomotopy | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Preadditive V]
{c : ComplexShape ι} {C D : HomologicalComplex V c} (j : ι), toPrev j = AddMonoidHom.mk' (fun f => f j (c.prev j)) ⋯ | true |
CategoryTheory.instCategoryObjOppositeSimplexCategoryNerve._aux_5 | Mathlib.AlgebraicTopology.SimplicialSet.Nerve | {C : Type u_1} →
[inst : CategoryTheory.Category.{u_2, u_1} C] →
{Δ : SimplexCategoryᵒᵖ} → {X Y Z : (CategoryTheory.nerve C).obj Δ} → (X ⟶ Y) → (Y ⟶ Z) → (X ⟶ Z) | false |
cauchy_davenport_of_isMulTorsionFree | Mathlib.Combinatorics.Additive.CauchyDavenport | ∀ {G : Type u_1} [inst : DecidableEq G] [inst_1 : Group G] [IsMulTorsionFree G] {s t : Finset G},
s.Nonempty → t.Nonempty → s.card + t.card - 1 ≤ (s * t).card | true |
Std.HashMap.Raw.beq | Std.Data.HashMap.Raw | {α : Type u} → {β : Type v} → [BEq α] → [Hashable α] → [BEq β] → Std.HashMap.Raw α β → Std.HashMap.Raw α β → Bool | true |
HEq.ndrecOn | Init.Core | {α : Sort u2} → {a : α} → {motive : {β : Sort u2} → β → Sort u1} → {β : Sort u2} → {b : β} → a ≍ b → motive a → motive b | true |
Finset.Nontrivial.ne_singleton | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} {s : Finset α} {a : α}, s.Nontrivial → s ≠ {a} | true |
CategoryTheory.Bicategory.associatorNatIsoRightCat_inv_toNatTrans_app | Mathlib.CategoryTheory.Bicategory.Yoneda | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} (f : a ⟶ b) (g : b ⟶ c) (d : B) (X : c ⟶ d),
(CategoryTheory.Bicategory.associatorNatIsoRightCat f g d).inv.toNatTrans.app X =
(CategoryTheory.Bicategory.associator f g X).inv | true |
conjneg_ne_one | Mathlib.Algebra.Star.Conjneg | ∀ {G : Type u_2} {R : Type u_3} [inst : AddGroup G] [inst_1 : CommSemiring R] [inst_2 : StarRing R] {f : G → R},
conjneg f ≠ 1 ↔ f ≠ 1 | true |
lTensor.inverse_of_rightInverse_apply | Mathlib.LinearAlgebra.TensorProduct.RightExactness | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} {P : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : AddCommGroup P] [inst_4 : Module R M] [inst_5 : Module R N] [inst_6 : Module R P]
{f : M →ₗ[R] N} {g : N →ₗ[R] P} (Q : Type u_5) [inst_7 : AddCommGroup Q] [inst_8 : Module ... | true |
CategoryTheory.cartesianClosedOfReflective'._proof_3 | Mathlib.CategoryTheory.Monoidal.Closed.Ideal | ∀ {C : Type u_3} {D : Type u_2} [inst : CategoryTheory.Category.{u_1, u_3} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (i : CategoryTheory.Functor D C)
[inst_2 : CategoryTheory.CartesianMonoidalCategory C] [inst_3 : CategoryTheory.Reflective i]
[inst_4 : CategoryTheory.CartesianMonoidalCategory D] (B : D) ... | false |
Lean.Widget.InfoPopup.rec | Lean.Server.FileWorker.WidgetRequests | {motive : Lean.Widget.InfoPopup → Sort u} →
((type exprExplicit : Option Lean.Widget.CodeWithInfos) →
(doc : Option String) → motive { type := type, exprExplicit := exprExplicit, doc := doc }) →
(t : Lean.Widget.InfoPopup) → motive t | false |
Lean.Lsp.DiagnosticSeverity.error.sizeOf_spec | Lean.Data.Lsp.Diagnostics | sizeOf Lean.Lsp.DiagnosticSeverity.error = 1 | true |
LTSeries.last_map | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (p : LTSeries α) (f : α → β)
(hf : StrictMono f), RelSeries.last (p.map f hf) = f (RelSeries.last p) | true |
Lean.Meta.Match.Extension.Entry.mk | Lean.Meta.Match.MatcherInfo | Lean.Name → Lean.Meta.MatcherInfo → Lean.Meta.Match.Extension.Entry | true |
NonUnitalStarSubalgebra.prod | Mathlib.Algebra.Star.NonUnitalSubalgebra | {R : Type u} →
{A : Type v} →
{B : Type w} →
[inst : CommSemiring R] →
[inst_1 : NonUnitalSemiring A] →
[inst_2 : StarRing A] →
[inst_3 : Module R A] →
[inst_4 : NonUnitalSemiring B] →
[inst_5 : StarRing B] →
[inst_6 : Module R B]... | true |
NonUnitalCommCStarAlgebra.toIsScalarTower | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {A : Type u_1} [self : NonUnitalCommCStarAlgebra A], IsScalarTower ℂ A A | true |
SimpleGraph.maximumIndepSet_exists | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_3} {G : SimpleGraph α} [inst : Finite α], ∃ s, G.IsMaximumIndepSet s | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_529 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w : α),
List.findIdxNth (fun x => decide (x = w)) [g (g a)] {g (g a)}.card + 1 ≤
(List.filter (fun x => decide (x = w)) []).length →
List.findIdxNth (fun x => decide (x = w)) [g (g a)] {g (g a)}.card <
(List.findIdxs (fun x => decid... | false |
VitaliFamily.ae_eventually_measure_zero_of_singular | Mathlib.MeasureTheory.Covering.Differentiation | ∀ {α : Type u_1} [inst : PseudoMetricSpace α] {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}
(v : VitaliFamily μ) [SecondCountableTopology α] [BorelSpace α] [MeasureTheory.IsLocallyFiniteMeasure μ]
{ρ : MeasureTheory.Measure α} [MeasureTheory.IsLocallyFiniteMeasure ρ],
ρ.MutuallySingular μ → ∀ᵐ (x : α) ∂μ... | true |
PosMulReflectLE.toPosMulStrictMono | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Defs | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Zero α] [inst_2 : LinearOrder α] [PosMulReflectLE α], PosMulStrictMono α | true |
Lean.Parser.Term.unsafe._regBuiltin.Lean.Parser.Term.unsafe_1 | Lean.Parser.Term | IO Unit | false |
Int16.or_self | Init.Data.SInt.Bitwise | ∀ {a : Int16}, a ||| a = a | true |
List.zip_eq_nil_iff._simp_1 | Init.Data.List.Zip | ∀ {α : Type u_1} {β : Type u_2} {l₁ : List α} {l₂ : List β}, (l₁.zip l₂ = []) = (l₁ = [] ∨ l₂ = []) | false |
Set.OrdConnected.predOrder._proof_10 | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] {s : Set α} [inst_1 : PredOrder α] (x : α) (hx : x ∈ s),
(if h : Order.pred ↑⟨x, hx⟩ ∈ s then ⟨Order.pred ↑⟨x, hx⟩, h⟩ else ⟨x, hx⟩) ≤ ⟨x, hx⟩ | false |
Nat.factorial_coe_dvd_prod | Mathlib.Data.Nat.Factorial.BigOperators | ∀ (k : ℕ) (n : ℤ), ↑k.factorial ∣ ∏ i ∈ Finset.range k, (n + ↑i) | true |
Finset.coe_insert | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α), ↑(insert a s) = insert a ↑s | true |
_private.Mathlib.Data.List.SplitBy.0.List.getLast?.match_1.eq_2 | Mathlib.Data.List.SplitBy | ∀ {α : Type u_1} (motive : List α → Sort u_2) (a : α) (as : List α) (h_1 : Unit → motive [])
(h_2 : (a : α) → (as : List α) → motive (a :: as)),
(match a :: as with
| [] => h_1 ()
| a :: as => h_2 a as) =
h_2 a as | true |
ContinuousMap.notMem_idealOfSet | Mathlib.Topology.ContinuousMap.Ideals | ∀ {X : Type u_1} {R : Type u_2} [inst : TopologicalSpace X] [inst_1 : Semiring R] [inst_2 : TopologicalSpace R]
[inst_3 : IsTopologicalSemiring R] {s : Set X} {f : C(X, R)}, f ∉ ContinuousMap.idealOfSet R s ↔ ∃ x ∈ sᶜ, f x ≠ 0 | true |
List.dropSlice.eq_1 | Batteries.Data.List.Basic | ∀ {α : Type u_1} (x x_1 : ℕ), List.dropSlice x x_1 [] = [] | true |
_private.Mathlib.Logic.Equiv.List.0.Encodable.encodeList.match_1.splitter | Mathlib.Logic.Equiv.List | {α : Type u_1} →
(motive : List α → Sort u_2) →
(x : List α) → (Unit → motive []) → ((a : α) → (l : List α) → motive (a :: l)) → motive x | true |
Std.Sat.AIG.Decl.relabel.match_1 | Std.Sat.AIG.Relabel | {α : Type} →
(motive : Std.Sat.AIG.Decl α → Sort u_1) →
(decl : Std.Sat.AIG.Decl α) →
(Unit → motive Std.Sat.AIG.Decl.false) →
((a : α) → motive (Std.Sat.AIG.Decl.atom a)) →
((lhs rhs : Std.Sat.AIG.Fanin) → motive (Std.Sat.AIG.Decl.gate lhs rhs)) → motive decl | false |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balance!_eq_balanceₘ._proof_1_34 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (ls : ℕ) (ll lr : Std.DTreeMap.Internal.Impl α β) (ls_1 lls : ℕ)
(l r : Std.DTreeMap.Internal.Impl α β) (lrs : ℕ) (lrl lrr : Std.DTreeMap.Internal.Impl α β),
3 * (ll.size + 1 + lr.size) < l.size + 1 + r.size + 1 + (lrl.size + 1 + lrr.size) →
ll.Balanced ∧
lr.Balanced ... | false |
CategoryTheory.enrichedFunctorTypeEquivFunctor._proof_2 | Mathlib.CategoryTheory.Enriched.Basic | ∀ {C : Type u_2} [𝒞 : CategoryTheory.EnrichedCategory (Type u_1) C] {D : Type u_3}
[𝒟 : CategoryTheory.EnrichedCategory (Type u_1) D] (F : CategoryTheory.Functor C D) (X Y Z : C),
(CategoryTheory.CategoryStruct.comp (CategoryTheory.eComp (Type u_1) X Y Z) fun f => F.map f) =
CategoryTheory.CategoryStruct.comp... | false |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balanceLErase.match_3.eq_3 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (rs : ℕ) (k : α) (v : β k) (l r : Std.DTreeMap.Internal.Impl α β) (ls : ℕ) (lk : α)
(lv : β lk)
(motive :
(ll lr : Std.DTreeMap.Internal.Impl α β) →
(Std.DTreeMap.Internal.Impl.inner ls lk lv ll lr).Balanced →
Std.DTreeMap.Internal.Impl.BalanceLErasePrecond (Std... | true |
Lean.Parser.Tactic.Conv._aux_Init_Conv___macroRules_Lean_Parser_Tactic_Conv_convIntro____1 | Init.Conv | Lean.Macro | false |
AlgebraicGeometry.Scheme.Cover.RelativeGluingData.glued | Mathlib.AlgebraicGeometry.RelativeGluing | {S : AlgebraicGeometry.Scheme} →
{𝒰 : S.OpenCover} →
[inst : CategoryTheory.Category.{u_2, u_1} 𝒰.I₀] →
[inst_1 : AlgebraicGeometry.Scheme.Cover.LocallyDirected 𝒰] →
AlgebraicGeometry.Scheme.Cover.RelativeGluingData 𝒰 →
[Small.{u, u_1} 𝒰.I₀] → [Quiver.IsThin 𝒰.I₀] → AlgebraicGeometry... | true |
ArchimedeanClass.liftOrderHom_mk | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] {α : Type u_2}
[inst_3 : PartialOrder α] (f : M → α) (h : ∀ (a b : M), ArchimedeanClass.mk a ≤ ArchimedeanClass.mk b → f a ≤ f b)
(a : M), (ArchimedeanClass.liftOrderHom f h) (ArchimedeanClass.mk a) = f a | true |
CategoryTheory.GrothendieckTopology.diagramPullback._proof_1 | Mathlib.CategoryTheory.Sites.Plus | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_4, u_3} C] (J : CategoryTheory.GrothendieckTopology C)
{D : Type u_2} [inst_1 : CategoryTheory.Category.{u_1, u_2} D]
[inst_2 :
∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : J.Cover X), CategoryTheory.Limits.HasMultiequalizer (S.index P)]
(P : CategoryTh... | false |
Subsemiring.closure_singleton_one | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u} [inst : NonAssocSemiring R], Subsemiring.closure {1} = ⊥ | true |
Std.ExtHashMap.getD_inter | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {fallback : β},
(m₁ ∩ m₂).getD k fallback = if k ∈ m₂ then m₁.getD k fallback else fallback | true |
Submonoid.LocalizationMap.map_surjective_of_surjOn | Mathlib.GroupTheory.MonoidLocalization.Maps | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N] {P : Type u_3}
[inst_2 : CommMonoid P] (f : S.LocalizationMap N) {g : M →* P} {T : Submonoid P} (hy : ∀ (y : ↥S), g ↑y ∈ T)
{Q : Type u_4} [inst_3 : CommMonoid Q] {k : T.LocalizationMap Q},
Set.SurjOn ⇑g ↑S ↑T → Functi... | true |
Lean.Meta.Grind.AC.EqCnstrProof.ctorIdx | Lean.Meta.Tactic.Grind.AC.Types | Lean.Meta.Grind.AC.EqCnstrProof → ℕ | false |
Lean.Compiler.LCNF.FloatLetIn.BaseFloatContext.mk | Lean.Compiler.LCNF.FloatLetIn | List (Lean.Compiler.LCNF.CodeDecl Lean.Compiler.LCNF.Purity.pure) → Lean.Compiler.LCNF.FloatLetIn.BaseFloatContext | true |
Subfield.rank_comap | Mathlib.FieldTheory.Relrank | ∀ {E : Type v} [inst : Field E] (A : Subfield E) {L : Type v} [inst_1 : Field L] (f : L →+* E),
Module.rank (↥(Subfield.comap f A)) L = A.relrank f.fieldRange | true |
ContinuousLinearMap.ebound | Mathlib.Analysis.Normed.Operator.Basic | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {E : Type u_4} {F : Type u_5} [inst : SeminormedAddCommGroup E]
[inst_1 : SeminormedAddCommGroup F] [inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NontriviallyNormedField 𝕜₂]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} [RingHomIsometric σ₁₂] (f : ... | true |
List.rotate_eq_nil_iff | Mathlib.Data.List.Rotate | ∀ {α : Type u} {l : List α} {n : ℕ}, l.rotate n = [] ↔ l = [] | true |
SubMulAction.ofFixingSubgroup_equivariantMap.eq_1 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfFixingSubgroup | ∀ (M : Type u_1) {α : Type u_2} [inst : Group M] [inst_1 : MulAction M α] (s : Set α),
SubMulAction.ofFixingSubgroup_equivariantMap M s = { toFun := fun x => ↑x, map_smul' := ⋯ } | true |
Ideal.comap._proof_6 | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u_1} {S : Type u_2} {F : Type u_3} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S]
(f : F) [RingHomClass F R S] (I : Ideal S) (c x : R), x ∈ ⇑f ⁻¹' ↑I → c • x ∈ ⇑f ⁻¹' ↑I | false |
Int64.toInt_maxValue | Init.Data.SInt.Lemmas | Int64.maxValue.toInt = 2 ^ 63 - 1 | true |
CategoryTheory.IsFilteredOrEmpty | Mathlib.CategoryTheory.Filtered.Basic | (C : Type u) → [CategoryTheory.Category.{v, u} C] → Prop | true |
Std.TreeMap.isEmpty_inter_iff | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp],
(t₁ ∩ t₂).isEmpty = true ↔ ∀ k ∈ t₁, k ∉ t₂ | true |
_private.Init.Meta.Defs.0.Lean.Name.hasNum._sunfold | Init.Meta.Defs | Lean.Name → Bool | false |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof.0.Lean.Meta.Grind.Arith.Cutsat.mkMulEqProof.go | Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof | Option Lean.Expr →
Array (Lean.Expr × ℤ × Lean.Meta.Grind.Arith.Cutsat.EqCnstr) →
Lean.Expr → Lean.Meta.Grind.Arith.Cutsat.ProofM✝ Lean.Meta.Grind.Arith.Cutsat.MulEqProof✝ | true |
ZeroHom.zero_comp | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} {P : Type u_6} [inst : Zero M] [inst_1 : Zero N] [inst_2 : Zero P] (f : ZeroHom M N),
ZeroHom.comp 0 f = 0 | true |
_private.Mathlib.CategoryTheory.Functor.TypeValuedFlat.0.CategoryTheory.FunctorToTypes.fromOverFunctorElementsEquivalence._proof_5 | Mathlib.CategoryTheory.Functor.TypeValuedFlat | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (F : CategoryTheory.Functor C (Type u_3)) {X : C}
(x : F.obj X) (X_1 : (CategoryTheory.FunctorToTypes.fromOverFunctor F x).Elements),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryOfElements.homMk
(CategoryTheory.Over.mk
... | false |
_private.Mathlib.SetTheory.ZFC.Rank.0.PSet.rank_powerset._simp_1_2 | Mathlib.SetTheory.ZFC.Rank | ∀ {x y : PSet.{u_1}}, (y ∈ x.powerset) = (y ⊆ x) | false |
Lean.ProjectionFunctionInfo.mk | Lean.ProjFns | Lean.Name → ℕ → ℕ → Bool → Lean.ProjectionFunctionInfo | true |
CFC.rpow_sqrt_nnreal | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | ∀ {A : Type u_1} [inst : PartialOrder A] [inst_1 : Ring A] [inst_2 : StarRing A] [inst_3 : TopologicalSpace A]
[inst_4 : StarOrderedRing A] [inst_5 : Algebra ℝ A] [inst_6 : ContinuousFunctionalCalculus ℝ A IsSelfAdjoint]
[inst_7 : NonnegSpectrumClass ℝ A] [IsSemitopologicalRing A] [T2Space A] {a : A} {x : NNReal},
... | true |
Real.mk_add | Mathlib.Data.Real.Basic | ∀ {f g : CauSeq ℚ abs}, Real.mk (f + g) = Real.mk f + Real.mk g | true |
LieModule.isLieAbelian_of_ker_traceForm_eq_bot | Mathlib.Algebra.Lie.TraceForm | ∀ (R : Type u_1) (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 M]
[LieRing.IsNilpotent L] [IsDomain R] [Module.Free R M] [Module.Finite R M],
LinearMap.ker (LieMo... | true |
SubMulAction.instOne | Mathlib.GroupTheory.GroupAction.SubMulAction.Pointwise | {R : Type u_1} → {M : Type u_2} → [inst : Monoid R] → [inst_1 : MulAction R M] → [One M] → One (SubMulAction R M) | true |
Function.const_inv | Mathlib.Algebra.Notation.Pi.Defs | ∀ {ι : Type u_1} {G : Type u_7} [inst : Inv G] (a : G), (Function.const ι a)⁻¹ = Function.const ι a⁻¹ | true |
instOrderBotSubtypeIsIdempotentElem._proof_1 | Mathlib.Algebra.Order.Ring.Idempotent | ∀ {M₀ : Type u_1} [inst : CommMonoidWithZero M₀], IsIdempotentElem 0 | false |
_private.Std.Sat.AIG.RefVecOperator.Map.0.Std.Sat.AIG.RefVec.denote_map._proof_1_1 | Std.Sat.AIG.RefVecOperator.Map | ∀ {len : ℕ} (idx : ℕ), ¬0 ≤ idx → False | false |
OpenSubgroup.instOrderTop._proof_1 | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G] (x : OpenSubgroup G), ↑x ⊆ Set.univ | false |
BddDistLat.Hom.Simps.hom | Mathlib.Order.Category.BddDistLat | (X Y : BddDistLat) → X.Hom Y → BoundedLatticeHom ↑X.toDistLat ↑Y.toDistLat | true |
Lean.Server.RequestContext | Lean.Server.Requests | Type | true |
AlgebraicGeometry.Scheme.Modules.Hom | Mathlib.AlgebraicGeometry.Modules.Sheaf | {X : AlgebraicGeometry.Scheme} → X.Modules → X.Modules → Type u | true |
Quaternion.imJ_coe | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} [inst : CommRing R] (x : R), (↑x).imJ = 0 | true |
LinearEquiv.extendScalarsOfSurjective | Mathlib.Algebra.Algebra.Basic | {R : Type u_1} →
{S : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : Semiring S] →
[inst_2 : Algebra R S] →
{M : Type u_3} →
{N : Type u_4} →
[inst_3 : AddCommMonoid M] →
[inst_4 : AddCommMonoid N] →
[inst_5 : Module R M] →
... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.