name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.Doc.Data.Option.noConfusionType | Lean.Elab.DocString.Builtin | Sort u → Lean.Doc.Data.Option → Lean.Doc.Data.Option → Sort u | false |
Lean.Expr.ReplaceLevelImpl.State._sizeOf_inst | Lean.Util.ReplaceLevel | SizeOf Lean.Expr.ReplaceLevelImpl.State | false |
List.Sublist.findIdx?_isSome | Init.Data.List.Find | ∀ {α : Type u_1} {p : α → Bool} {l₁ l₂ : List α},
l₁.Sublist l₂ → (List.findIdx? p l₁).isSome = true → (List.findIdx? p l₂).isSome = true | true |
_private.Mathlib.Data.Finset.Dedup.0.Multiset.toFinset_subset._simp_1_1 | Mathlib.Data.Finset.Dedup | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ ⊆ s₂) = ∀ ⦃x : α⦄, x ∈ s₁ → x ∈ s₂ | false |
Matrix.uniqueAlgEquiv | Mathlib.LinearAlgebra.Matrix.Unique | {m : Type u_1} →
{A : Type u_3} →
{R : Type u_4} →
[inst : Unique m] →
[inst_1 : Semiring A] → [inst_2 : CommSemiring R] → [inst_3 : Algebra R A] → Matrix m m A ≃ₐ[R] A | true |
Lean.Parser.Tactic.revert | Init.Tactics | Lean.ParserDescr | true |
_private.Mathlib.Analysis.SpecialFunctions.BinaryEntropy.0.Real.strictConcaveOn_qaryEntropy._simp_1_1 | Mathlib.Analysis.SpecialFunctions.BinaryEntropy | ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, (x ∈ Set.Ioo a b) = (a < x ∧ x < b) | false |
SetLike.GradeZero.coe_intCast | Mathlib.Algebra.DirectSum.Internal | ∀ {ι : Type u_1} {σ : Type u_2} {R : Type u_4} [inst : Ring R] [inst_1 : AddMonoid ι] [inst_2 : SetLike σ R]
[inst_3 : AddSubgroupClass σ R] (A : ι → σ) [inst_4 : SetLike.GradedMonoid A] (z : ℤ), ↑↑z = ↑z | true |
CategoryTheory.Adjunction.homEquiv | Mathlib.CategoryTheory.Adjunction.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
{G : CategoryTheory.Functor D C} → (F ⊣ G) → (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G.obj Y) | true |
Filter.Realizer.ctorIdx | Mathlib.Data.Analysis.Filter | {α : Type u_1} → {f : Filter α} → f.Realizer → ℕ | false |
Lean.Doc.Part.brecOn_1 | Lean.DocString.Types | {i : Type u} →
{b : Type v} →
{p : Type w} →
{motive_1 : Lean.Doc.Part i b p → Sort u_1} →
{motive_2 : Array (Lean.Doc.Part i b p) → Sort u_1} →
{motive_3 : List (Lean.Doc.Part i b p) → Sort u_1} →
(t : Array (Lean.Doc.Part i b p)) →
((t : Lean.Doc.Part i b p) → t... | false |
Representation.FiniteCyclicGroup.coinvariantsEquiv | Mathlib.RepresentationTheory.Homological.FiniteCyclic | {k : Type u_1} →
{G : Type u_2} →
[inst : CommRing k] →
[inst_1 : Group G] →
{V : Type u_4} →
[inst_2 : AddCommGroup V] →
[inst_3 : Module k V] →
(ρ : Representation k G V) →
(g : G) →
[Fintype G] →
(∀ (x : G),... | true |
String.validFor_mkIterator | Batteries.Data.String.Lemmas | ∀ (s : String), String.Legacy.Iterator.ValidFor [] s.toList (String.Legacy.mkIterator s) | true |
AlgebraicGeometry.Scheme.instOverSpecResidueField | Mathlib.AlgebraicGeometry.ResidueField | {X : AlgebraicGeometry.Scheme} → (x : ↥X) → (AlgebraicGeometry.Spec (X.residueField x)).Over X | true |
HomologicalComplex.restriction.sc'Iso_hom_τ₃ | Mathlib.Algebra.Homology.Embedding.RestrictionHomology | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(K : HomologicalComplex C c') (e : c.Embedding c') [inst_2 : e.IsRelIff] (i j k : ι) {i' j' k' : ι'}
(hi' : e.f i = i') (hj'... | true |
List.set_eq_modify | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} (a : α) (n : ℕ) (l : List α), l.set n a = l.modify n fun x => a | true |
CongruenceSubgroup.Gamma1_mem._simp_1 | Mathlib.NumberTheory.ModularForms.CongruenceSubgroups | ∀ (N : ℕ) (A : Matrix.SpecialLinearGroup (Fin 2) ℤ),
(A ∈ CongruenceSubgroup.Gamma1 N) = (↑(↑A 0 0) = 1 ∧ ↑(↑A 1 1) = 1 ∧ ↑(↑A 1 0) = 0) | false |
isAddRegular_toColex | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : AddMonoid α] {a : α}, IsAddRegular (toColex a) ↔ IsAddRegular a | true |
_private.Mathlib.CategoryTheory.Comma.Over.Basic.0.CategoryTheory.Over.isRightAdjoint_post.match_1 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} T] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] {G : CategoryTheory.Functor D T} (motive : G.IsRightAdjoint → Prop)
(x : G.IsRightAdjoint), (∀ (F : CategoryTheory.Functor T D) (a : F ⊣ G), motive ⋯) → motive x | false |
MeasureTheory.JordanDecomposition.casesOn | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan | {α : Type u_2} →
[inst : MeasurableSpace α] →
{motive : MeasureTheory.JordanDecomposition α → Sort u} →
(t : MeasureTheory.JordanDecomposition α) →
((posPart negPart : MeasureTheory.Measure α) →
[posPart_finite : MeasureTheory.IsFiniteMeasure posPart] →
[negPart_finite : Me... | false |
RingEquiv.nonUnitalSubsemiringCongr._proof_1 | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u_1} [inst : NonUnitalNonAssocSemiring R] {s t : NonUnitalSubsemiring R}, s = t → ↑s = ↑t | false |
AffineMap.finrank_eq | Mathlib.LinearAlgebra.AffineSpace.FiniteDimensional | ∀ {R : Type u_1} {S : Type u_2} {V : Type u_3} {W : Type u_4} {P : Type u_5} [inst : Ring R] [inst_1 : Ring S]
[inst_2 : AddCommGroup V] [inst_3 : Module R V] [Module.Finite R V] [Module.Free R V] [inst_6 : AddTorsor V P]
[inst_7 : AddCommGroup W] [inst_8 : Module R W] [inst_9 : Module S W] [Module.Finite S W]
[i... | true |
PerfectionMap.lift._proof_4 | Mathlib.RingTheory.Perfection | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)] (R : Type u_1) [inst_1 : CommSemiring R] [inst_2 : CharP R p]
[inst_3 : PerfectRing R p] (S : Type u_2) [inst_4 : CommSemiring S] [inst_5 : CharP S p] (P : Type u_3)
[inst_6 : CommSemiring P] [inst_7 : CharP P p] [inst_8 : PerfectRing P p] (π : P →+* S) (m : PerfectionMap p π)
... | false |
AlgebraicGeometry.LocallyRingedSpace.restrict_presheaf_map | Mathlib.Geometry.RingedSpace.LocallyRingedSpace | ∀ {U : TopCat} (X : AlgebraicGeometry.LocallyRingedSpace) {f : U ⟶ X.toTopCat}
(h : Topology.IsOpenEmbedding ⇑(CategoryTheory.ConcreteCategory.hom f)) {X_1 Y : (TopologicalSpace.Opens ↑U)ᵒᵖ}
(f_1 : X_1 ⟶ Y), (X.restrict h).presheaf.map f_1 = X.presheaf.map (h.functor.map f_1.unop).op | true |
FiberBundleCore.Index | Mathlib.Topology.FiberBundle.Basic | {ι : Type u_1} →
{B : Type u_2} →
{F : Type u_3} → [inst : TopologicalSpace B] → [inst_1 : TopologicalSpace F] → FiberBundleCore ι B F → Type u_1 | true |
Lean.Meta.Grind.instInhabitedTheorems.default | Lean.Meta.Tactic.Grind.Theorems | {a : Type} → Lean.Meta.Grind.Theorems a | true |
CategoryTheory.ShortComplex.ShortExact.singleδ.eq_1 | Mathlib.Algebra.Homology.DerivedCategory.SingleTriangle | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : HasDerivedCategory C] {S : CategoryTheory.ShortComplex C} (hS : S.ShortExact),
hS.singleδ =
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.SingleFunctors.evaluation C (DerivedCategory C) 0).mapIso
... | true |
BooleanSubalgebra.instCompleteLattice._proof_4 | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_1} [inst : BooleanAlgebra α] (_L _M : BooleanSubalgebra α) (_a : α), _a ∈ ↑_L ∧ _a ∈ ↑_M → _a ∈ ↑_M | false |
_private.Mathlib.Topology.ShrinkingLemma.0.ShrinkingLemma.PartialRefinement.chainSup._simp_8 | Mathlib.Topology.ShrinkingLemma | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | false |
Quiver.symmetrifyStar | Mathlib.Combinatorics.Quiver.Covering | {U : Type u_1} →
[inst : Quiver U] → (u : U) → Quiver.Star (Quiver.Symmetrify.of.obj u) ≃ Quiver.Star u ⊕ Quiver.Costar u | true |
_private.Mathlib.RingTheory.Unramified.LocalStructure.0.Algebra.IsUnramifiedAt.exists_hasStandardEtaleSurjectionOn_of_exists_adjoin_singleton_eq_top._simp_1_17 | Mathlib.RingTheory.Unramified.LocalStructure | ∀ {α : Type u_1} [inst : NonUnitalRing α] {a b c : α}, a ∣ c → (a ∣ b + c) = (a ∣ b) | false |
Lean.Compiler.LCNF.eqvTypes | Lean.Compiler.LCNF.InferType | Lean.Expr → Lean.Expr → Bool | true |
eventuallyMeasurableSpace._proof_1 | Mathlib.MeasureTheory.MeasurableSpace.EventuallyMeasurable | ∀ {α : Type u_1} (m : MeasurableSpace α) (l : Filter α), ∃ t, MeasurableSet t ∧ ∅ =ᶠ[l] t | false |
Lean.Elab.Tactic.RCases.RCasesPatt.one | Lean.Elab.Tactic.RCases | Lean.Syntax → Lean.Name → Lean.Elab.Tactic.RCases.RCasesPatt | true |
AlgebraicGeometry.Scheme.mem_zeroLocus_iff._simp_1 | Mathlib.AlgebraicGeometry.Scheme | ∀ (X : AlgebraicGeometry.Scheme) {U : X.Opens} (s : Set ↑(X.presheaf.obj (Opposite.op U))) (x : ↥X),
(x ∈ X.zeroLocus s) = ∀ f ∈ s, x ∉ X.basicOpen f | false |
Mathlib.Tactic.Coherence.LiftHom.noConfusion | Mathlib.Tactic.CategoryTheory.Coherence | {P : Sort u_1} →
{C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{X Y : C} →
{inst_1 : Mathlib.Tactic.Coherence.LiftObj X} →
{inst_2 : Mathlib.Tactic.Coherence.LiftObj Y} →
{f : X ⟶ Y} →
{t : Mathlib.Tactic.Coherence.LiftHom f} →
{C' : T... | false |
Lean.Meta.ZetaUnusedMode.ctorElim | Lean.Meta.HaveTelescope | {motive : Lean.Meta.ZetaUnusedMode → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Meta.ZetaUnusedMode) → ctorIdx = t.ctorIdx → Lean.Meta.ZetaUnusedMode.ctorElimType ctorIdx → motive t | false |
Mathlib.Tactic.DepRewrite.Conv.depRw | Mathlib.Tactic.DepRewrite | Lean.ParserDescr | true |
_private.Mathlib.Combinatorics.Additive.FreimanHom.0.Fin.isAddFreimanIso_Iio._simp_1_1 | Mathlib.Combinatorics.Additive.FreimanHom | ∀ (n : ℕ) [inst : NeZero n], 0 = ⊥ | false |
MulArchimedeanOrder.le_def | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : Group M] [inst_1 : Lattice M] {a b : MulArchimedeanOrder M},
a ≤ b ↔ ∃ n, |MulArchimedeanOrder.val b|ₘ ≤ |MulArchimedeanOrder.val a|ₘ ^ n | true |
ContinuousLinearMap.reApplyInnerSelf_continuous | Mathlib.Analysis.InnerProductSpace.LinearMap | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(T : E →L[𝕜] E), Continuous T.reApplyInnerSelf | true |
_private.Mathlib.NumberTheory.Chebyshev.0.Chebyshev.primeCounting_eq_theta_div_log_add_integral._simp_1_7 | Mathlib.NumberTheory.Chebyshev | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False | false |
CategoryTheory.WithInitial.of.injEq | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} (a a_1 : C), (CategoryTheory.WithInitial.of a = CategoryTheory.WithInitial.of a_1) = (a = a_1) | true |
conditionallyCompleteLatticeOfLatticeOfsSup | Mathlib.Order.ConditionallyCompleteLattice.Defs | (α : Type u_5) →
[H1 : Lattice α] →
[inst : SupSet α] → (∀ (s : Set α), BddAbove s → s.Nonempty → IsLUB s (sSup s)) → ConditionallyCompleteLattice α | true |
Lean.Linter.UnusedVariables.References.casesOn | Lean.Linter.UnusedVariables | {motive : Lean.Linter.UnusedVariables.References → Sort u} →
(t : Lean.Linter.UnusedVariables.References) →
((constDecls : Std.HashSet Lean.Syntax.Range) →
(fvarDefs : Std.HashMap Lean.Syntax.Range Lean.Linter.UnusedVariables.FVarDefinition) →
(fvarUses : Std.HashSet Lean.FVarId) →
(... | false |
CategoryTheory.PreZeroHypercover.Hom.mk.injEq | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E : CategoryTheory.PreZeroHypercover S}
{F : CategoryTheory.PreZeroHypercover S} (s₀ : E.I₀ → F.I₀) (h₀ : (i : E.I₀) → E.X i ⟶ F.X (s₀ i))
(w₀ :
autoParam (∀ (i : E.I₀), CategoryTheory.CategoryStruct.comp (h₀ i) (F.f (s₀ i)) = E.f i)
Catego... | true |
Equiv.Set.sumDiffSubset_apply_inl | Mathlib.Logic.Equiv.Set | ∀ {α : Type u_3} {s t : Set α} (h : s ⊆ t) [inst : DecidablePred fun x => x ∈ s] (x : ↑s),
(Equiv.Set.sumDiffSubset h) (Sum.inl x) = Set.inclusion h x | true |
_private.Mathlib.Algebra.Regular.Defs.0.isRegular_iff.match_1_3 | Mathlib.Algebra.Regular.Defs | ∀ {R : Type u_1} [inst : Mul R] {c : R} (motive : IsLeftRegular c ∧ IsRightRegular c → Prop)
(x : IsLeftRegular c ∧ IsRightRegular c), (∀ (h1 : IsLeftRegular c) (h2 : IsRightRegular c), motive ⋯) → motive x | false |
Option.forIn'_join._proof_1 | Init.Data.Option.Monadic | ∀ {α : Type u_1} (o : Option (Option α)), ∀ o' ∈ o, ∀ a ∈ o', a ∈ o.join | false |
_private.Lean.Meta.Tactic.Grind.EMatch.0.Lean.Meta.Grind.EMatch.checkDefEq.match_1 | Lean.Meta.Tactic.Grind.EMatch | (motive : Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr → Sort u_1) →
(__discr : Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr) →
((fst : Array Lean.Expr) → (fst_1 : Array Lean.BinderInfo) → (rhsExpr : Lean.Expr) → motive (fst, fst_1, rhsExpr)) →
motive __discr | false |
_private.Lean.OriginalConstKind.0.Lean.wasOriginallyTheorem.match_1 | Lean.OriginalConstKind | (motive : Lean.ConstantKind → Sort u_1) →
(x : Lean.ConstantKind) → (Unit → motive Lean.ConstantKind.thm) → ((x : Lean.ConstantKind) → motive x) → motive x | false |
CategoryTheory.ShortComplex.rightHomologyIso_hom_comp_homologyι_assoc | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [inst_2 : S.HasHomology] {Z : C} (h : S.opcycles ⟶ Z),
CategoryTheory.CategoryStruct.comp S.rightHomologyIso.hom (CategoryTheory.CategoryStruct.comp S.homologyι h) =
C... | true |
MeasurableEquiv.curry_apply | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ (ι : Type u_6) (κ : Type u_7) (X : Type u_8) [inst : MeasurableSpace X] (a : ι × κ → X) (a_1 : ι) (a_2 : κ),
(MeasurableEquiv.curry ι κ X) a a_1 a_2 = a (a_1, a_2) | true |
Prod.instCompleteAtomicBooleanAlgebra._proof_9 | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteAtomicBooleanAlgebra α] [inst_1 : CompleteAtomicBooleanAlgebra β]
(x : α × β), x ⊓ xᶜ ≤ ⊥ | false |
Std.ExtDHashMap.getKey?_modify | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α] {k k' : α}
{f : β k → β k}, (m.modify k f).getKey? k' = if (k == k') = true then if k ∈ m then some k else none else m.getKey? k' | true |
Lean.Lsp.LeanIdentifier.mk._flat_ctor | Lean.Data.Lsp.Internal | Lean.Name → Lean.Name → Bool → Lean.Lsp.LeanIdentifier | false |
ZMod.ringEquivCongr._proof_1 | Mathlib.Data.ZMod.Basic | ∀ (m n : ℕ) (h : m + 1 = n + 1) (a b : ZMod (m + 1)),
(finCongr h).toFun (a * b) = (finCongr h).toFun a * (finCongr h).toFun b | false |
isotypicComponents | Mathlib.RingTheory.SimpleModule.Isotypic | (R : Type u_2) →
(M : Type u) → [inst : Ring R] → [inst_1 : AddCommGroup M] → [inst_2 : Module R M] → Set (Submodule R M) | true |
Bundle.Trivialization.liftCM.eq_1 | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_1} {F : Type u_2} {Z : Type u_4} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] {proj : Z → B}
[inst_2 : TopologicalSpace Z] (T : Bundle.Trivialization F proj),
T.liftCM = { toFun := fun ex => ⟨T.lift ↑ex.1 ↑ex.2, ⋯⟩, continuous_toFun := ⋯ } | true |
_private.Std.Sat.CNF.Dimacs.0.Std.Sat.CNF.DimacsState.numClauses._default | Std.Sat.CNF.Dimacs | ℕ | false |
System.Uri.UriEscape.letterF | Init.System.Uri | UInt8 | true |
Lean.Meta.LazyDiscrTree.instInhabitedKey | Lean.Meta.LazyDiscrTree | Inhabited Lean.Meta.LazyDiscrTree.Key | true |
_private.Mathlib.Tactic.Simps.Basic.0.NameStruct.mk.inj | Mathlib.Tactic.Simps.Basic | ∀ {parent : Lean.Name} {components : List String} {parent_1 : Lean.Name} {components_1 : List String},
{ parent := parent, components := components } = { parent := parent_1, components := components_1 } →
parent = parent_1 ∧ components = components_1 | true |
_private.Std.Time.Zoned.Database.TZdb.0.Std.Time.Database.TZdb.localRules.match_1 | Std.Time.Zoned.Database.TZdb | (motive : Option String → Sort u_1) →
(x : Option String) → ((id : String) → motive (some id)) → ((x : Option String) → motive x) → motive x | false |
Dioph.diophFn_vec_comp1 | Mathlib.NumberTheory.Dioph | ∀ {n : ℕ} {S : Set (Vector3 ℕ n.succ)},
Dioph S → ∀ {f : Vector3 ℕ n → ℕ}, Dioph.DiophFn f → Dioph {v | Vector3.cons (f v) v ∈ S} | true |
RingHom.map_adjugate | Mathlib.LinearAlgebra.Matrix.Adjugate | ∀ {n : Type v} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type u_1} {S : Type u_2} [inst_2 : CommRing R]
[inst_3 : CommRing S] (f : R →+* S) (M : Matrix n n R), f.mapMatrix M.adjugate = (f.mapMatrix M).adjugate | true |
EuclideanGeometry.Sphere.self_mem_orthRadius | Mathlib.Geometry.Euclidean.Sphere.OrthRadius | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] (s : EuclideanGeometry.Sphere P) (p : P), p ∈ s.orthRadius p | true |
_private.Mathlib.Computability.Language.0.Language.kstar_eq_iSup_pow._simp_1_2 | Mathlib.Computability.Language | ∀ {α : Type u_1} {ι : Sort v} {l : ι → Language α} {x : List α}, (x ∈ ⨆ i, l i) = ∃ i, x ∈ l i | false |
Multiset.mem_Ioc._simp_1 | Mathlib.Order.Interval.Multiset | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α},
(x ∈ Multiset.Ioc a b) = (a < x ∧ x ≤ b) | false |
_private.Mathlib.Analysis.Normed.Affine.AddTorsorBases.0.AffineBasis.centroid_mem_interior_convexHull._simp_1_2 | Mathlib.Analysis.Normed.Affine.AddTorsorBases | ∀ {α : Type u_3} [inst : Semiring α] [inst_1 : PartialOrder α] [IsOrderedRing α] [Nontrivial α] {n : ℕ},
(0 < ↑n) = (0 < n) | false |
Std.PRange.UpwardEnumerable.succMany_eq_get | Init.Data.Range.Polymorphic.UpwardEnumerable | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : Std.PRange.LawfulUpwardEnumerable α]
[inst_2 : Std.PRange.InfinitelyUpwardEnumerable α] {n : ℕ} {a : α},
Std.PRange.succMany n a = (Std.PRange.succMany? n a).get ⋯ | true |
Lean.Expr.NumApps.State.casesOn | Lean.Util.NumApps | {motive : Lean.Expr.NumApps.State → Sort u} →
(t : Lean.Expr.NumApps.State) →
((visited : Lean.PtrSet Lean.Expr) →
(counters : Lean.NameMap ℕ) → motive { visited := visited, counters := counters }) →
motive t | false |
Lean.Elab.Visibility.noConfusionType | Lean.Elab.DeclModifiers | Sort v✝ → Lean.Elab.Visibility → Lean.Elab.Visibility → Sort v✝ | true |
PresheafOfModules.ofPresheaf_map | Mathlib.Algebra.Category.ModuleCat.Presheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
(M : CategoryTheory.Functor Cᵒᵖ Ab) [inst_1 : (X : Cᵒᵖ) → Module ↑(R.obj X) ↑(M.obj X)]
(map_smul :
∀ ⦃X Y : Cᵒᵖ⦄ (f : X ⟶ Y) (r : ↑(R.obj X)) (m : ↑(M.obj X)),
(CategoryTheory.ConcreteCategory.hom (M.map ... | true |
MeasureTheory.Measure.ae_ae_eq_curry_of_prod | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {μ : MeasureTheory.Measure α}
{ν : MeasureTheory.Measure β} [MeasureTheory.SFinite ν] {γ : Type u_4} {f g : α × β → γ},
f =ᵐ[μ.prod ν] g → ∀ᵐ (x : α) ∂μ, Function.curry f x =ᵐ[ν] Function.curry g x | true |
DirectLimit.Ring.lift._proof_1 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_2} [inst : Preorder ι] (G : ι → Type u_3) {T : ⦃i j : ι⦄ → i ≤ j → Type u_4}
(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 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι]
[inst_4 : (i : ι) → NonAssocSemir... | false |
CategoryTheory.Bicategory.mateEquiv_symm_apply' | Mathlib.CategoryTheory.Bicategory.Adjunction.Mate | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {c d e f : B} {g : c ⟶ e} {h : d ⟶ f} {l₁ : c ⟶ d} {r₁ : d ⟶ c}
{l₂ : e ⟶ f} {r₂ : f ⟶ e} (adj₁ : CategoryTheory.Bicategory.Adjunction l₁ r₁)
(adj₂ : CategoryTheory.Bicategory.Adjunction l₂ r₂)
(β : CategoryTheory.CategoryStruct.comp r₁ g ⟶ CategoryTheory.Catego... | true |
Int.Linear.Poly.divAll.eq_def | Init.Data.Int.Linear | ∀ (k : ℤ) (x : Int.Linear.Poly),
Int.Linear.Poly.divAll k x =
match x with
| Int.Linear.Poly.num k' => k' % k == 0
| Int.Linear.Poly.add k' v p => k' % k == 0 && Int.Linear.Poly.divAll k p | true |
MeasureTheory.VectorMeasure.equivMeasure_symm_apply | Mathlib.MeasureTheory.VectorMeasure.Basic | ∀ {α : Type u_1} [inst : MeasurableSpace α] (μ : MeasureTheory.Measure α),
MeasureTheory.VectorMeasure.equivMeasure.symm μ = μ.toENNRealVectorMeasure | true |
Dynamics.dynEntourage_univ | Mathlib.Dynamics.TopologicalEntropy.DynamicalEntourage | ∀ {X : Type u_1} {T : X → X} {n : ℕ}, Dynamics.dynEntourage T Set.univ n = Set.univ | true |
IsLowerSet.compl | Mathlib.Order.UpperLower.Basic | ∀ {α : Type u_1} [inst : LE α] {s : Set α}, IsLowerSet s → IsUpperSet sᶜ | true |
BoxIntegral.Prepartition.mem_disjUnion._simp_1 | Mathlib.Analysis.BoxIntegral.Partition.Basic | ∀ {ι : Type u_1} {I J : BoxIntegral.Box ι} {π₁ π₂ : BoxIntegral.Prepartition I} (H : Disjoint π₁.iUnion π₂.iUnion),
(J ∈ π₁.disjUnion π₂ H) = (J ∈ π₁ ∨ J ∈ π₂) | false |
Std.DHashMap.Internal.AssocList.cons.injEq | Std.Data.DHashMap.Internal.AssocList.Basic | ∀ {α : Type u} {β : α → Type v} (key : α) (value : β key) (tail : Std.DHashMap.Internal.AssocList α β) (key_1 : α)
(value_1 : β key_1) (tail_1 : Std.DHashMap.Internal.AssocList α β),
(Std.DHashMap.Internal.AssocList.cons key value tail = Std.DHashMap.Internal.AssocList.cons key_1 value_1 tail_1) =
(key = key_1 ... | true |
Subspace.quotAnnihilatorEquiv._proof_2 | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {K : Type u_1} [inst : Field K], RingHomCompTriple (RingHom.id K) (RingHom.id K) (RingHom.id K) | false |
Disjoint.exists_open_convexes | Mathlib.Topology.Algebra.Module.LocallyConvex | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜]
[inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E] [inst_5 : TopologicalSpace E] [IsTopologicalAddGroup E]
[ContinuousConstSMul 𝕜 E] [LocallyConvexSpace 𝕜 E] {s t : Set E},
Disjoint s t →
Convex 𝕜 s →
... | true |
Matroid.uniqueBaseOn_isBase_iff | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} {E B I : Set α}, I ⊆ E → ((Matroid.uniqueBaseOn I E).IsBase B ↔ B = I) | true |
ascPochhammer_zero | Mathlib.RingTheory.Polynomial.Pochhammer | ∀ (S : Type u) [inst : Semiring S], ascPochhammer S 0 = 1 | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_268 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | false |
CategoryTheory.Limits.hasPullback_unop_iff_hasPushout._simp_1 | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Pullbacks | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : Cᵒᵖ} (f : X ⟶ Y) (g : X ⟶ Z),
CategoryTheory.Limits.HasPullback f.unop g.unop = CategoryTheory.Limits.HasPushout f g | false |
Lean.Meta.Cases.Context.recOn | Lean.Meta.Tactic.Cases | {motive : Lean.Meta.Cases.Context → Sort u} →
(t : Lean.Meta.Cases.Context) →
((inductiveVal : Lean.InductiveVal) →
(nminors : ℕ) →
(majorDecl : Lean.LocalDecl) →
(majorTypeFn : Lean.Expr) →
(majorTypeArgs majorTypeIndices : Array Lean.Expr) →
motive
... | false |
AddGrpCat.instConcreteCategoryAddMonoidHomCarrier._proof_2 | Mathlib.Algebra.Category.Grp.Basic | ∀ {X Y : AddGrpCat} (f : X ⟶ Y), { hom' := f.hom' } = f | false |
FractionalIdeal.coeIdeal_mul._simp_1 | Mathlib.RingTheory.FractionalIdeal.Basic | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
(I J : Ideal R), ↑I * ↑J = ↑(I * J) | false |
Matrix.blockDiag_map | Mathlib.Data.Matrix.Block | ∀ {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type u_12} {β : Type u_13} (M : Matrix (m × o) (n × o) α)
(f : α → β), (M.map f).blockDiag = fun k => (M.blockDiag k).map f | true |
Finset.biUnion_op_vadd_finset | Mathlib.Algebra.Group.Action.Pointwise.Finset | ∀ {α : Type u_2} [inst : Add α] [inst_1 : DecidableEq α] (s t : Finset α),
(t.biUnion fun a => AddOpposite.op a +ᵥ s) = s + t | true |
_private.Init.Data.Slice.List.Lemmas.0.List.toArray_mkSlice_rcc._simp_1_1 | Init.Data.Slice.List.Lemmas | ∀ {α : Type u_1} {xs : ListSlice α}, Std.Slice.toArray xs = (Std.Slice.toList xs).toArray | false |
not_of_iff_false | Init.Core | ∀ {p : Prop}, (p ↔ False) → ¬p | true |
Polynomial.scaleRoots_dvd_iff | Mathlib.RingTheory.Polynomial.ScaleRoots | ∀ {R : Type u_1} [inst : CommSemiring R] (p q : Polynomial R) {r : R},
IsUnit r → (p.scaleRoots r ∣ q.scaleRoots r ↔ p ∣ q) | true |
SimpleGraph.mk.sizeOf_spec | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u} [inst : SizeOf V] (Adj : V → V → Prop) (symm : autoParam (Symmetric Adj) SimpleGraph.symm._autoParam)
(loopless : autoParam (Std.Irrefl Adj) SimpleGraph.loopless._autoParam),
sizeOf { Adj := Adj, symm := symm, loopless := loopless } = 1 + sizeOf loopless | true |
_private.Std.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.0.Std.IterM.stepAsHetT_filterMapWithPostcondition.match_3.eq_1 | Std.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {m : Type u_1 → Type u_2} {α β : Type u_1} (motive : Std.IterStep (Std.IterM m β) β → Sort u_3) (it' : Std.IterM m β)
(out : β) (h_1 : (it' : Std.IterM m β) → (out : β) → motive (Std.IterStep.yield it' out))
(h_2 : (it' : Std.IterM m β) → motive (Std.IterStep.skip it')) (h_3 : Unit → motive Std.IterStep.done),
... | true |
_private.Init.Data.Ord.Vector.0.Vector.instReflOrd._proof_1 | Init.Data.Ord.Vector | ∀ {α : Type u_1} [inst : Ord α] [Std.ReflOrd α] {n : ℕ}, Std.ReflOrd (Vector α n) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.