name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Pi.instOrderBotLexForallOfWellFoundedLT | Mathlib.Order.PiLex | {ι : Type u_1} →
{β : ι → Type u_2} →
[inst : LinearOrder ι] →
[WellFoundedLT ι] →
[inst_2 : (a : ι) → PartialOrder (β a)] → [(a : ι) → OrderBot (β a)] → OrderBot (Lex ((a : ι) → β a)) | true |
LucasLehmer.X.ofNat_snd | Mathlib.NumberTheory.LucasLehmer | ∀ {q : ℕ} (n : ℕ) [inst : n.AtLeastTwo], (OfNat.ofNat n).2 = 0 | true |
Mathlib.Tactic.FieldSimp.zero_zpow' | Mathlib.Tactic.FieldSimp.Lemmas | ∀ {α : Type u_1} [inst : GroupWithZero α] (n : ℤ), Mathlib.Tactic.FieldSimp.zpow' 0 n = 0 | true |
Metric.packingNumber.eq_1 | Mathlib.Topology.MetricSpace.CoveringNumbers | ∀ {X : Type u_1} [inst : PseudoEMetricSpace X] (ε : NNReal) (A : Set X),
Metric.packingNumber ε A = ⨆ C, ⨆ (_ : C ⊆ A), ⨆ (_ : Metric.IsSeparated (↑ε) C), C.encard | true |
Computation.rel_of_liftRel | Mathlib.Data.Seq.Computation | ∀ {α : Type u} {β : Type v} {R : α → β → Prop} {ca : Computation α} {cb : Computation β},
Computation.LiftRel R ca cb → ∀ {a : α} {b : β}, a ∈ ca → b ∈ cb → R a b | true |
IsMaxFilter.bicomp_mono | Mathlib.Order.Filter.Extr | ∀ {α : Type u} {β : Type v} {γ : Type w} {δ : Type x} [inst : Preorder β] [inst_1 : Preorder γ] {f : α → β}
{l : Filter α} {a : α} [inst_2 : Preorder δ] {op : β → γ → δ},
Relator.LiftFun (fun x1 x2 => x1 ≤ x2) (Relator.LiftFun (fun x1 x2 => x1 ≤ x2) fun x1 x2 => x1 ≤ x2) op op →
IsMaxFilter f l a → ∀ {g : α → γ... | true |
FiniteField.Matrix.charpoly_pow_card | Mathlib.LinearAlgebra.Matrix.Charpoly.FiniteField | ∀ {n : Type u_1} [inst : DecidableEq n] [inst_1 : Fintype n] {K : Type u_2} [inst_2 : Field K] [inst_3 : Fintype K]
(M : Matrix n n K), (M ^ Fintype.card K).charpoly = M.charpoly | true |
_private.Mathlib.Analysis.MeanInequalities.0.Real.Lp_add_le._simp_1_4 | Mathlib.Analysis.MeanInequalities | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : AddCommGroup α] [AddLeftMono α] (a b : α), (|a + b| ≤ |a| + |b|) = True | false |
_private.Mathlib.RingTheory.FractionalIdeal.Operations.0.IsFractional.div_of_nonzero.match_1_1 | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R₁ : Type u_1} [inst : CommRing R₁] {K : Type u_2} [inst_1 : Field K] [inst_2 : Algebra R₁ K] {I J : Submodule R₁ K}
(motive : IsFractional (nonZeroDivisors R₁) I → IsFractional (nonZeroDivisors R₁) J → J ≠ 0 → Prop)
(x : IsFractional (nonZeroDivisors R₁) I) (x_1 : IsFractional (nonZeroDivisors R₁) J) (x_2 : J ≠... | false |
HomologicalComplex.instQuasiIsoAtMapOppositeSymmUnopFunctorOp | Mathlib.Algebra.Homology.Opposite | ∀ {ι : Type u_1} {V : Type u_2} [inst : CategoryTheory.Category.{v_1, u_2} V] {c : ComplexShape ι}
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {K L : HomologicalComplex Vᵒᵖ c} (φ : K ⟶ L) (i : ι)
[inst_2 : K.HasHomology i] [inst_3 : L.HasHomology i] [QuasiIsoAt φ i],
QuasiIsoAt ((HomologicalComplex.unopFu... | true |
Bundle.Trivialization.restrictPreimage'_source | 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] (e : Bundle.Trivialization F proj) (s : Set B)
[inst_3 : Nonempty (↑s → F → ↑(proj ⁻¹' s))],
(e.restrictPreimage' s).source = Subtype.val ⁻¹' e.toPretrivialization.... | true |
CochainComplex.homologyFunctorFactors_hom_app_homologyδOfTriangle._auto_1 | Mathlib.Algebra.Homology.DerivedCategory.HomologySequence | Lean.Syntax | false |
CategoryTheory.Limits.FormalCoproduct.isLimitPullbackCone._proof_3 | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {X Y Z : CategoryTheory.Limits.FormalCoproduct C}
(f : X ⟶ Z) (g : Y ⟶ Z)
(pb :
(i : Function.Pullback f.f g.f) →
CategoryTheory.Limits.PullbackCone (CategoryTheory.CategoryStruct.comp (f.φ (↑i).1) (CategoryTheory.eqToHom ⋯))
(g.φ (↑i)... | false |
ContinuousLinearMap.definition._@.Mathlib.Analysis.Normed.Operator.Banach.754268252._hygCtx._hyg.2 | Mathlib.Analysis.Normed.Operator.Banach | {𝕜 : Type u_1} →
{𝕜' : Type u_2} →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : NontriviallyNormedField 𝕜'] →
{σ : 𝕜 →+* 𝕜'} →
{E : Type u_3} →
[inst_2 : NormedAddCommGroup E] →
[inst_3 : NormedSpace 𝕜 E] →
{F : Type u_4} →
... | false |
_private.Mathlib.Order.Filter.SmallSets.0.Filter.smallSets_eq_generate._simp_1_2 | Mathlib.Order.Filter.SmallSets | ∀ {α : Type u_1} {f : Filter α} {s : Set α}, (s ∈ f.sets) = (s ∈ f) | false |
_private.Init.Data.UInt.Lemmas.0.UInt64.ofNat_eq_iff_mod_eq_toNat._simp_1_1 | Init.Data.UInt.Lemmas | ∀ {a b : UInt64}, (a = b) = (a.toNat = b.toNat) | false |
AddMonoidHom.coe_ofMapMidpoint | Mathlib.LinearAlgebra.AffineSpace.Midpoint | ∀ (R : Type u_1) (R' : Type u_2) {E : Type u_3} {F : Type u_4} [inst : Ring R] [inst_1 : Invertible 2]
[inst_2 : AddCommGroup E] [inst_3 : Module R E] [inst_4 : Ring R'] [inst_5 : Invertible 2] [inst_6 : AddCommGroup F]
[inst_7 : Module R' F] (f : E → F) (h0 : f 0 = 0) (hm : ∀ (x y : E), f (midpoint R x y) = midpoi... | true |
CategoryTheory.IsFiltered.filteredClosure.below.base | Mathlib.CategoryTheory.Filtered.Small | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.IsFilteredOrEmpty C] {α : Type w}
{f : α → C} {motive : (a : C) → CategoryTheory.IsFiltered.filteredClosure f a → Prop} (x : α),
CategoryTheory.IsFiltered.filteredClosure.below ⋯ | true |
Std.HashMap.noConfusion | Std.Data.HashMap.Basic | {P : Sort u_1} →
{α : Type u} →
{β : Type v} →
{inst : BEq α} →
{inst_1 : Hashable α} →
{t : Std.HashMap α β} →
{α' : Type u} →
{β' : Type v} →
{inst' : BEq α'} →
{inst'_1 : Hashable α'} →
{t' : Std.HashMap α' ... | false |
CategoryTheory.Subgroupoid.instCompleteLattice._proof_5 | Mathlib.CategoryTheory.Groupoid.Subgroupoid | ∀ {C : Type u_2} [inst : CategoryTheory.Groupoid C] (s : Set (CategoryTheory.Subgroupoid C)), IsLUB s (sSup s) | false |
Bool.false_lt_true | Mathlib.Data.Bool.Basic | false < true | true |
Pi.canLift | Mathlib.Tactic.Lift | ∀ (ι : Sort u_1) (α : ι → Sort u_2) (β : ι → Sort u_3) (coe : (i : ι) → β i → α i) (P : (i : ι) → α i → Prop)
[∀ (i : ι), CanLift (α i) (β i) (coe i) (P i)],
CanLift ((i : ι) → α i) ((i : ι) → β i) (fun f i => coe i (f i)) fun f => ∀ (i : ι), P i (f i) | true |
Filter.mem_inf_iff | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {f g : Filter α} {s : Set α}, s ∈ f ⊓ g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, s = t₁ ∩ t₂ | true |
StronglyLocallyContractibleSpace.locallyContractible | Mathlib.Topology.Homotopy.LocallyContractible | ∀ {X : Type u_1} [inst : TopologicalSpace X] [StronglyLocallyContractibleSpace X], LocallyContractibleSpace X | true |
localCohomology.diagram._proof_1 | Mathlib.Algebra.Homology.LocalCohomology | ∀ {R : Type u_1} [inst : CommRing R], CategoryTheory.EnoughProjectives (ModuleCat R) | false |
Real.goldenRatio_add_goldenConj | Mathlib.NumberTheory.Real.GoldenRatio | Real.goldenRatio + Real.goldenConj = 1 | true |
AdicCompletion.eval._proof_1 | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(n : ℕ) (x x_1 : AdicCompletion I M), ↑(x + x_1) n = ↑(x + x_1) n | false |
UniformOnFun.gen_mem_nhds | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | ∀ {α : Type u_1} (β : Type u_2) {s : Set α} [inst : UniformSpace β] (𝔖 : Set (Set α)) (f : UniformOnFun α β 𝔖),
s ∈ 𝔖 →
∀ {V : Set (β × β)},
V ∈ uniformity β → {g | ∀ x ∈ s, ((UniformOnFun.toFun 𝔖) f x, (UniformOnFun.toFun 𝔖) g x) ∈ V} ∈ nhds f | true |
String.find | Init.Data.String.Search | {ρ : Type} →
{σ : String.Slice → Type} →
[inst : (s : String.Slice) → Std.Iterator (σ s) Id (String.Slice.Pattern.SearchStep s)] →
[(s : String.Slice) → Std.IteratorLoop (σ s) Id Id] →
(s : String) → (pattern : ρ) → [String.Slice.Pattern.ToForwardSearcher pattern σ] → s.Pos | true |
LieAlgebra.SemiDirectSum.mk.sizeOf_spec | Mathlib.Algebra.Lie.SemiDirect | ∀ {R : Type u_1} [inst : CommRing R] {K : Type u_2} [inst_1 : LieRing K] [inst_2 : LieAlgebra R K] {L : Type u_3}
[inst_3 : LieRing L] [inst_4 : LieAlgebra R L] {x : L →ₗ⁅R⁆ LieDerivation R K K} [inst_5 : SizeOf R]
[inst_6 : SizeOf K] [inst_7 : SizeOf L] (left : K) (right : L),
sizeOf { left := left, right := rig... | true |
_private.Mathlib.SetTheory.Cardinal.HasCardinalLT.0.HasCardinalLT.exists_regular_cardinal._simp_1_1 | Mathlib.SetTheory.Cardinal.HasCardinalLT | ∀ (X : Type u) (κ : Cardinal.{u}), HasCardinalLT X κ = (Cardinal.mk X < κ) | false |
_private.Init.Grind.Module.Envelope.0.Lean.Grind.IntModule.OfNatModule.exists_true._simp_1 | Init.Grind.Module.Envelope | ∀ (α : Type u) [Lean.Grind.NatModule α], (∃ x, True) = True | false |
Polynomial.derivative_one | Mathlib.Algebra.Polynomial.Derivative | ∀ {R : Type u} [inst : Semiring R], Polynomial.derivative 1 = 0 | true |
FirstOrder.Language.presburger.natCast_succ._simp_1 | Mathlib.ModelTheory.Arithmetic.Presburger.Basic | ∀ {α : Type u_1} (n : ℕ), ↑n + 1 = ↑(n + 1) | false |
_private.Mathlib.Topology.FiberBundle.Basic.0.FiberBundleCore.open_source'._simp_1_1 | Mathlib.Topology.FiberBundle.Basic | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | false |
Vector.ofFnM_pure_comp | Init.Data.Vector.OfFn | ∀ {m : Type u_1 → Type u_2} {α : Type u_1} [inst : Monad m] [LawfulMonad m] {n : ℕ} {f : Fin n → α},
Vector.ofFnM (pure ∘ f) = pure (Vector.ofFn f) | true |
CategoryTheory.WithTerminal.id.eq_2 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C], CategoryTheory.WithTerminal.star.id = PUnit.unit | true |
MeasureTheory.setToFun_const | Mathlib.MeasureTheory.Integral.SetToL1 | ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
[inst_4 : CompleteSpace F] {T : Set α → E →L[ℝ] F} {C : ℝ} [MeasureTheory.IsFiniteMeasure μ]
(hT ... | true |
DifferentiableWithinAt.inner | Mathlib.Analysis.InnerProductSpace.Calculus | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : NormedSpace ℝ E] {G : Type u_4} [inst_4 : NormedAddCommGroup G] [inst_5 : NormedSpace ℝ G] {f g : G → E}
{s : Set G} {x : G},
DifferentiableWithinAt ℝ f s x →
DifferentiableWithinAt ... | true |
List.lookmap.go.eq_1 | Mathlib.Data.List.Lookmap | ∀ {α : Type u_1} (f : α → Option α) (x : Array α), List.lookmap.go f [] x = x.toList | true |
Std.DTreeMap.Internal.Impl.Const.minEntry._unary._proof_1 | Std.Data.DTreeMap.Internal.Queries | ∀ {α : Type u_1} {β : Type u_2}, WellFounded (invImage (fun x => PSigma.casesOn x fun t h => t) sizeOfWFRel).1 | false |
Lean.Elab.Command.PreElabHeaderResult.origParams | Lean.Elab.MutualInductive | Lean.Elab.Command.PreElabHeaderResult → Array Lean.Expr | true |
HasStrictFDerivAt.exists_lipschitzOnWith_of_nnnorm_lt | Mathlib.Analysis.Calculus.FDeriv.Basic | ∀ {𝕜 : 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}
{f' : E →L[𝕜] F} {x : E}, HasStrictFDerivAt f f' x → ∀ (K : NNReal), ‖f'‖₊ < K → ∃ s ∈ nhds x, Lips... | true |
CategoryTheory.SmallObject.SuccStruct.restrictionLTOfCoconeIso_hom_app | Mathlib.CategoryTheory.SmallObject.Iteration.FunctorOfCocone | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {J : Type u} [inst_1 : LinearOrder J] {j : J}
{F : CategoryTheory.Functor (↑(Set.Iio j)) C} (c : CategoryTheory.Limits.Cocone F) (X : ↑(Set.Iio j)),
(CategoryTheory.SmallObject.SuccStruct.restrictionLTOfCoconeIso c).hom.app X =
(CategoryTheory.Small... | true |
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis.uninteresting._default | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic | Std.HashSet Lean.Name | false |
WithZero.mapAddHom_id | Mathlib.Algebra.Group.WithOne.Basic | ∀ {α : Type u} [inst : Add α], WithZero.mapAddHom (AddHom.id α) = AddMonoidHom.id (WithZero α) | true |
_private.Lean.Widget.InteractiveDiagnostic.0.Lean.Widget.EmbedFmt.ignoreTags.elim | Lean.Widget.InteractiveDiagnostic | {motive : Lean.Widget.EmbedFmt✝ → Sort u} →
(t : Lean.Widget.EmbedFmt✝¹) →
Lean.Widget.EmbedFmt.ctorIdx✝ t = 4 → motive Lean.Widget.EmbedFmt.ignoreTags✝ → motive t | false |
CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_41 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | Lean.Syntax | false |
Lean.Doc.Block.ol.injEq | Lean.DocString.Types | ∀ {i : Type u} {b : Type v} (start : ℤ) (items : Array (Lean.Doc.ListItem (Lean.Doc.Block i b))) (start_1 : ℤ)
(items_1 : Array (Lean.Doc.ListItem (Lean.Doc.Block i b))),
(Lean.Doc.Block.ol start items = Lean.Doc.Block.ol start_1 items_1) = (start = start_1 ∧ items = items_1) | true |
Lean.Grind.Int8.intCast_ofNat | Init.GrindInstances.Ring.SInt | ∀ (x : ℕ), ↑(OfNat.ofNat x) = OfNat.ofNat x | true |
Lean.Lsp.instToJsonInlayHintTooltip.match_1 | Lean.Data.Lsp.LanguageFeatures | (motive : Lean.Lsp.InlayHintTooltip → Sort u_1) →
(x : Lean.Lsp.InlayHintTooltip) →
((text : String) → motive (Lean.Lsp.InlayHintTooltip.plaintext text)) →
((markup : Lean.Lsp.MarkupContent) → motive (Lean.Lsp.InlayHintTooltip.markdown markup)) → motive x | false |
Mathlib.Tactic.Monoidal.tacticMonoidal_nf | Mathlib.Tactic.CategoryTheory.Monoidal.Basic | Lean.ParserDescr | true |
BitVec.extractLsb | Init.Data.BitVec.Basic | {n : ℕ} → (hi lo : ℕ) → BitVec n → BitVec (hi - lo + 1) | true |
_private.Init.Data.Range.Polymorphic.PRange.0.Std.instDecidableEqRoi.decEq._proof_1 | Init.Data.Range.Polymorphic.PRange | ∀ {α : Type u_1} (a : α), a<...* = a<...* | false |
_private.Lean.Elab.Tactic.Do.VCGen.SuggestInvariant.0.Lean.Elab.Tactic.Do.hasEarlyReturn | Lean.Elab.Tactic.Do.VCGen.SuggestInvariant | Array Lean.MVarId → Lean.MVarId → Lean.Expr → Lean.MetaM (Option (Lean.Expr × Lean.Expr)) | true |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof.0.Lean.Meta.Grind.Arith.Cutsat.LeCnstr.collectDecVars.match_1 | Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof | (motive : Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof → Sort u_1) →
(x : Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof) →
((e : Lean.Expr) → motive (Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.core e)) →
((e : Lean.Expr) → (p : Int.Linear.Poly) → motive (Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.coreNeg e p)) →
... | false |
Lean.Elab.Term.CollectPatternVars.Context.noConfusionType | Lean.Elab.PatternVar | Sort u → Lean.Elab.Term.CollectPatternVars.Context → Lean.Elab.Term.CollectPatternVars.Context → Sort u | false |
_private.Mathlib.NumberTheory.ModularForms.JacobiTheta.TwoVariable.0.jacobiTheta₂'_conj._simp_1_5 | Mathlib.NumberTheory.ModularForms.JacobiTheta.TwoVariable | ∀ (n : ℤ), ↑n = ↑↑n | false |
Lean.SMap.instForInProdOfMonad | Lean.Data.SMap | {α : Type u} →
{β : Type v} →
[inst : BEq α] → [inst_1 : Hashable α] → {m : Type u_1 → Type u_2} → [Monad m] → ForIn m (Lean.SMap α β) (α × β) | true |
_private.Mathlib.CategoryTheory.Sites.DenseSubsite.Basic.0.CategoryTheory.Functor.IsCoverDense.Types.naturality_apply._simp_1_2 | Mathlib.CategoryTheory.Sites.DenseSubsite.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.CategoryStruct.{v₁, u₁} C] {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z},
CategoryTheory.CategoryStruct.comp g.op f.op = (CategoryTheory.CategoryStruct.comp f g).op | false |
IsSelfAdjoint.invOf | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : Monoid R] [inst_1 : StarMul R] (x : R) [inst_2 : Invertible x],
IsSelfAdjoint x → IsSelfAdjoint ⅟x | true |
AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.of_stalk_iso | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {X Y : AlgebraicGeometry.LocallyRingedSpace} (f : X ⟶ Y),
Topology.IsOpenEmbedding ⇑(CategoryTheory.ConcreteCategory.hom f.base) →
∀
[stalk_iso :
∀ (x : ↑↑X.toPresheafedSpace), CategoryTheory.IsIso (AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap f x)],
AlgebraicGeometry.LocallyRingedSpace... | true |
UniformSpace.ext | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type ua} {u₁ u₂ : UniformSpace α}, uniformity α = uniformity α → u₁ = u₂ | true |
CategoryTheory.MorphismProperty.regularEpi | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | (C : Type u₁) → [inst : CategoryTheory.Category.{v₁, u₁} C] → CategoryTheory.MorphismProperty C | true |
SemiRingCat.FilteredColimits.colimitSemiring._proof_10 | Mathlib.Algebra.Category.Ring.FilteredColimits | ∀ {J : Type u_2} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J SemiRingCat)
[inst_1 : CategoryTheory.IsFiltered J] (x : ↑(SemiRingCat.FilteredColimits.R F)), Monoid.npow 0 x = 1 | false |
SimpleGraph.IsTree.isBipartite | Mathlib.Combinatorics.SimpleGraph.Acyclic | ∀ {V : Type u_1} {G : SimpleGraph V}, G.IsTree → G.IsBipartite | true |
CategoryTheory.Functor.associator._proof_4 | Mathlib.CategoryTheory.Functor.Category | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} D] {E : Type u_8} [inst_2 : CategoryTheory.Category.{u_7, u_8} E]
{E' : Type u_4} [inst_3 : CategoryTheory.Category.{u_3, u_4} E'] (F : CategoryTheory.Functor C D)
(G : CategoryTheory.Functor... | false |
_private.Mathlib.MeasureTheory.Constructions.BorelSpace.Basic.0.Prod.opensMeasurableSpace._simp_3 | Mathlib.MeasureTheory.Constructions.BorelSpace.Basic | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, b ∧ p x) = (b ∧ ∃ x, p x) | false |
CategoryTheory.Preadditive.moduleEndRight._proof_2 | Mathlib.CategoryTheory.Preadditive.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C}
(x : X ⟶ Y), CategoryTheory.CategoryStruct.comp x 0 = 0 | false |
PresheafOfModules.unitHomEquiv._proof_4 | Mathlib.Algebra.Category.ModuleCat.Presheaf | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_3, u_2} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
(M : PresheafOfModules R) (s : M.sections),
(fun f => PresheafOfModules.sectionsMk (fun X => (CategoryTheory.ConcreteCategory.hom (f.app X)) 1) ⋯)
((fun s =>
{ app := fun X => ModuleCat.ofHom ((Li... | false |
WeierstrassCurve.VariableChange.instGroup._proof_5 | Mathlib.AlgebraicGeometry.EllipticCurve.VariableChange | ∀ {R : Type u_1} [inst : CommRing R] (n : ℕ) (x : WeierstrassCurve.VariableChange R),
npowRecAuto (n + 1) x = npowRecAuto n x * x | false |
Representation.IntertwiningMap.ofBijective._proof_2 | Mathlib.RepresentationTheory.Intertwining | ∀ {A : Type u_3} {G : Type u_4} {V : Type u_1} {W : Type u_2} [inst : CommSemiring A] [inst_1 : Monoid G]
[inst_2 : AddCommMonoid V] [inst_3 : AddCommMonoid W] [inst_4 : Module A V] [inst_5 : Module A W]
{ρ : Representation A G V} {σ : Representation A G W} (f : ρ.IntertwiningMap σ) (hf : Function.Bijective ⇑f),
... | false |
CategoryTheory.Limits.IsCofiltered.sequentialFunctor | Mathlib.CategoryTheory.Limits.Shapes.Countable | (J : Type u_2) → [Countable J] → [inst : Preorder J] → [CategoryTheory.IsCofiltered J] → CategoryTheory.Functor ℕᵒᵖ J | true |
Lean.Compiler.LCNF.Param.mk.injEq | Lean.Compiler.LCNF.Basic | ∀ {pu : Lean.Compiler.LCNF.Purity} (fvarId : Lean.FVarId) (binderName : Lean.Name) (type : Lean.Expr) (borrow : Bool)
(fvarId_1 : Lean.FVarId) (binderName_1 : Lean.Name) (type_1 : Lean.Expr) (borrow_1 : Bool),
({ fvarId := fvarId, binderName := binderName, type := type, borrow := borrow } =
{ fvarId := fvarId... | true |
Option.elim'_update | Mathlib.Data.Option.Basic | ∀ {α : Type u_5} {β : Type u_6} [inst : DecidableEq α] (f : β) (g : α → β) (a : α) (x : β),
Option.elim' f (Function.update g a x) = Function.update (Option.elim' f g) (some a) x | true |
_private.Lean.Meta.Tactic.Grind.AC.Seq.0.Lean.Grind.AC.StartsWithResult.ctorElim | Lean.Meta.Tactic.Grind.AC.Seq | {motive : Lean.Grind.AC.StartsWithResult✝ → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Grind.AC.StartsWithResult✝¹) →
ctorIdx = Lean.Grind.AC.StartsWithResult.ctorIdx✝ t →
Lean.Grind.AC.StartsWithResult.ctorElimType✝ ctorIdx → motive t | false |
OrthonormalBasis.equiv_symm | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {ι' : Type u_2} {𝕜 : Type u_3} [inst : RCLike 𝕜] {E : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : Fintype ι] {E' : Type u_7} [inst_4 : Fintype ι']
[inst_5 : NormedAddCommGroup E'] [inst_6 : InnerProductSpace 𝕜 E'] (b : OrthonormalBasis ι 𝕜 E)
(b' : Or... | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.maxKeyD_le_maxKeyD_insertIfNew._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | false |
AddMonoidAlgebra.support_one_subset | Mathlib.Algebra.MonoidAlgebra.Support | ∀ {k : Type u₁} {G : Type u₂} [inst : Semiring k] [inst_1 : Zero G], Finsupp.support 1 ⊆ 0 | true |
CategoryTheory.Limits.ChosenPullback₃.w₂_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.ChosenPullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X₁ X₂ X₃ S : C} {f₁ : X₁ ⟶ S} {f₂ : X₂ ⟶ S} {f₃ : X₃ ⟶ S}
{h₁₂ : CategoryTheory.Limits.ChosenPullback f₁ f₂} {h₂₃ : CategoryTheory.Limits.ChosenPullback f₂ f₃}
{h₁₃ : CategoryTheory.Limits.ChosenPullback f₁ f₃} (h : CategoryTheory.Limits.ChosenPullback₃ h₁₂ ... | true |
Lean.Parser.Term.anonymousCtor._regBuiltin.Lean.Parser.Term.anonymousCtor.docString_3 | Lean.Parser.Term | IO Unit | false |
PartitionOfUnity.sum_nonneg | Mathlib.Topology.PartitionOfUnity | ∀ {ι : Type u} {X : Type v} [inst : TopologicalSpace X] {s : Set X} (f : PartitionOfUnity ι X s) (x : X),
0 ≤ ∑ᶠ (i : ι), (f i) x | true |
FirstOrder.Language.order.instStrongHomClassOfOrderIsoClass | Mathlib.ModelTheory.Order | ∀ {M : Type w'} [inst : FirstOrder.Language.order.Structure M] [inst_1 : LE M]
[FirstOrder.Language.order.OrderedStructure M] {N : Type u_1} [inst_3 : FirstOrder.Language.order.Structure N]
[inst_4 : LE N] [FirstOrder.Language.order.OrderedStructure N] {F : Type u_2} [inst_6 : EquivLike F M N]
[OrderIsoClass F M ... | true |
TopCat.LocalPredicate.rec | Mathlib.Topology.Sheaves.LocalPredicate | {X : TopCat} →
{T : ↑X → Type u_1} →
{motive : TopCat.LocalPredicate T → Sort u} →
((toPrelocalPredicate : TopCat.PrelocalPredicate T) →
(locality :
∀ {U : TopologicalSpace.Opens ↑X} (f : (x : ↥U) → T ↑x),
(∀ (x : ↥U), ∃ V, ∃ (_ : ↑x ∈ V), ∃ i, toPrelocalPredicate.pre... | false |
Array.getElem?_eraseIdx_of_lt | Init.Data.Array.Erase | ∀ {α : Type u_1} {xs : Array α} {i : ℕ} (h : i < xs.size) {j : ℕ}, j < i → (xs.eraseIdx i h)[j]? = xs[j]? | true |
MeasureTheory.GridLines.T_empty | Mathlib.Analysis.FunctionalSpaces.SobolevInequality | ∀ {ι : Type u_1} {A : ι → Type u_2} [inst : (i : ι) → MeasurableSpace (A i)] (μ : (i : ι) → MeasureTheory.Measure (A i))
[inst_1 : DecidableEq ι] {p : ℝ} (f : ((i : ι) → A i) → ENNReal) (x : (i : ι) → A i),
MeasureTheory.GridLines.T μ p f ∅ x = f x ^ (1 + p) | true |
List.le_sum_of_mem | Mathlib.Algebra.Order.BigOperators.Group.List | ∀ {M : Type u_3} [inst : AddMonoid M] [inst_1 : Preorder M] [CanonicallyOrderedAdd M] {xs : List M} {x : M},
x ∈ xs → x ≤ xs.sum | true |
TensorProduct.AlgebraTensorModule.rTensor._proof_4 | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ (R : Type u_5) {A : Type u_1} {M : Type u_2} (N : Type u_4) {P : Type u_3} [inst : CommSemiring R]
[inst_1 : Semiring A] [inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module A M]
[inst_6 : IsScalarTower R A M] [inst_7 : AddCommMonoid N] [inst_8 : Module R N] [inst_9 : AddCommMo... | false |
_private.Lean.Compiler.LCNF.InferType.0.Lean.Compiler.LCNF.InferType.Pure.inferLetValueType.match_1 | Lean.Compiler.LCNF.InferType | (motive : Lean.Compiler.LCNF.LetValue Lean.Compiler.LCNF.Purity.pure → Sort u_1) →
(e : Lean.Compiler.LCNF.LetValue Lean.Compiler.LCNF.Purity.pure) →
(Unit → motive Lean.Compiler.LCNF.LetValue.erased) →
((v : Lean.Compiler.LCNF.LitValue) → motive (Lean.Compiler.LCNF.LetValue.lit v)) →
((structName :... | false |
IteratedWreathProduct_succ | Mathlib.GroupTheory.RegularWreathProduct | ∀ (G : Type u) (n : ℕ), IteratedWreathProduct G (n + 1) = IteratedWreathProduct G n ≀ᵣ G | true |
Lean.Parser.Tactic.MCasesPat.tuple.elim | Std.Tactic.Do.Syntax | {motive_1 : Lean.Parser.Tactic.MCasesPat → Sort u} →
(t : Lean.Parser.Tactic.MCasesPat) →
t.ctorIdx = 2 →
((args : List Lean.Parser.Tactic.MCasesPat) → motive_1 (Lean.Parser.Tactic.MCasesPat.tuple args)) → motive_1 t | false |
List.Vector.pmap_cons._proof_4 | Mathlib.Data.Vector.Basic | ∀ {α : Type u_1} {n : ℕ} {p : α → Prop} (a : α) (v : List.Vector α n),
(∀ x ∈ (a ::ᵥ v).toList, p x) → ∀ x ∈ v.toList, p x | false |
_private.Init.Data.Iterators.Producers.Monadic.List.0.Std.Iterators.Types.ListIterator.ext.match_1 | Init.Data.Iterators.Producers.Monadic.List | ∀ {α : Type u_1} (motive : Std.Iterators.Types.ListIterator α → Prop) (h : Std.Iterators.Types.ListIterator α),
(∀ (list : List α), motive { list := list }) → motive h | false |
isOpen_iff_continuous_mem | Mathlib.Topology.Order | ∀ {α : Type u_1} [inst : TopologicalSpace α] {s : Set α}, IsOpen s ↔ Continuous fun x => x ∈ s | true |
MeasureTheory.instIsZeroOrProbabilityMeasureMap | Mathlib.MeasureTheory.Measure.Typeclasses.Probability | ∀ {α : Type u_1} {β : Type u_2} {m0 : MeasurableSpace α} [inst : MeasurableSpace β] {μ : MeasureTheory.Measure α}
[MeasureTheory.IsZeroOrProbabilityMeasure μ] {f : α → β},
MeasureTheory.IsZeroOrProbabilityMeasure (MeasureTheory.Measure.map f μ) | true |
UniformEquiv.image | Mathlib.Topology.UniformSpace.Equiv | {α : Type u} →
{β : Type u_1} → [inst : UniformSpace α] → [inst_1 : UniformSpace β] → (e : α ≃ᵤ β) → (s : Set α) → ↑s ≃ᵤ ↑(⇑e '' s) | true |
_private.Lean.Elab.Tactic.Do.VCGen.Basic.0.Lean.Elab.Tactic.Do.withLocalSpecs.loop._unsafe_rec | Lean.Elab.Tactic.Do.VCGen.Basic | {m : Type → Type u_1} →
{α : Type} →
[inst : MonadControlT Lean.Elab.Tactic.Do.VCGenM m] →
Array Lean.Expr →
m α →
({β : Type} → m β → Lean.Elab.Tactic.Do.VCGenM (stM Lean.Elab.Tactic.Do.VCGenM m β)) →
ℕ → Lean.Elab.Tactic.Do.VCGenM (stM Lean.Elab.Tactic.Do.VCGenM m α) | false |
Ideal.mem_torsionOf_iff | Mathlib.Algebra.Module.Torsion.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (x : M) (a : R),
a ∈ Ideal.torsionOf R M x ↔ a • x = 0 | true |
Plausible.Configuration.mk | Plausible.Testable | ℕ → ℕ → ℕ → Bool → Bool → Bool → Bool → Option ℕ → Bool → Plausible.Configuration | true |
contDiff_one_iff_hasFDerivAt | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : 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},
ContDiff 𝕜 1 f ↔ ∃ f', Continuous f' ∧ ∀ (x : E), HasFDerivAt f (f' x) x | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.