name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Mathlib.Meta.NormNum.isNat_ordinalSub | Mathlib.Tactic.NormNum.Ordinal | ∀ {a b : Ordinal.{u}} {an bn rn : ℕ},
Mathlib.Meta.NormNum.IsNat a an →
Mathlib.Meta.NormNum.IsNat b bn → an - bn = rn → Mathlib.Meta.NormNum.IsNat (a - b) rn | null | true |
SSet.Truncated.mapFundamentalGroupoid | Mathlib.AlgebraicTopology.SimplicialSet.FundamentalGroupoid.Basic | {X Y : SSet.Truncated 2} → (X ⟶ Y) → CategoryTheory.Functor X.FundamentalGroupoid Y.FundamentalGroupoid | The functor `FundamentalGroupoid X ⥤ FundamentalGroupoid Y` that is induced
by a morphism of `2`-truncated simplicial sets. | true |
_private.Mathlib.Algebra.Field.Periodic.0.Function.Periodic.exists_mem_Ico₀.match_1_1 | Mathlib.Algebra.Field.Periodic | ∀ {α : Type u_1} {c : α} [inst : AddCommGroup α] [inst_1 : LinearOrder α] (x : α)
(motive : (∃! k, 0 ≤ x - k • c ∧ x - k • c < c) → Prop) (x_1 : ∃! k, 0 ≤ x - k • c ∧ x - k • c < c),
(∀ (n : ℤ) (H : 0 ≤ x - n • c ∧ x - n • c < c)
(right : ∀ (y : ℤ), (fun k => 0 ≤ x - k • c ∧ x - k • c < c) y → y = n), motive ... | null | false |
hasMFDerivWithinAt_insert | Mathlib.Geometry.Manifold.MFDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | null | true |
List.Pairwise.imp_of_mem | Init.Data.List.Pairwise | ∀ {α : Type u_1} {l : List α} {R S : α → α → Prop},
(∀ {a b : α}, a ∈ l → b ∈ l → R a b → S a b) → List.Pairwise R l → List.Pairwise S l | null | true |
Matrix.TransvectionStruct | Mathlib.LinearAlgebra.Matrix.Transvection | Type u_1 → Type u₂ → Type (max u_1 u₂) | A structure containing all the information from which one can build a nontrivial transvection.
This structure is easier to manipulate than transvections as one has a direct access to all the
relevant fields. | true |
Lean.Kernel.Exception.other.noConfusion | Lean.Environment | {P : Sort u} →
{msg msg' : String} → Lean.Kernel.Exception.other msg = Lean.Kernel.Exception.other msg' → (msg = msg' → P) → P | null | false |
CategoryTheory.HasShift.induced._proof_5 | Mathlib.CategoryTheory.Shift.Induced | ∀ {C : Type u_5} {D : Type u_2} [inst : CategoryTheory.Category.{u_4, u_5} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (F : CategoryTheory.Functor C D) (A : Type u_3) [inst_2 : AddMonoid A]
[inst_3 : CategoryTheory.HasShift C A] (s : A → CategoryTheory.Functor D D)
(i : (a : A) → F.comp (s a) ≅ (CategoryTh... | null | false |
_private.Mathlib.Data.Set.Lattice.Disjoint.0.Set.biUnion_compl_eq_of_pairwise_disjoint_of_iUnion_eq_univ._simp_1_5 | Mathlib.Data.Set.Lattice.Disjoint | ∀ {a b : Prop}, (¬a ↔ ¬b) = (a ↔ b) | null | false |
IsContMDiffRiemannianBundle.rec | Mathlib.Geometry.Manifold.VectorBundle.Riemannian | {EB : Type u_1} →
[inst : NormedAddCommGroup EB] →
[inst_1 : NormedSpace ℝ EB] →
{HB : Type u_2} →
[inst_2 : TopologicalSpace HB] →
{IB : ModelWithCorners ℝ EB HB} →
{n : WithTop ℕ∞} →
{B : Type u_3} →
[inst_3 : TopologicalSpace B] →
... | null | false |
_private.Lean.Data.Lsp.Communication.0.Lean.IO.FS.Stream.isLean3Request | Lean.Data.Lsp.Communication | String → Bool | Returns true when the string is a Lean 3 request.
This means that the user is running a Lean 3 language client that
is not aware of Lean 4. In this case we should give a friendlier message. | true |
Lean.Grind.CommRing.Poly.denote_mulC_nc_go | Init.Grind.Ring.CommSolver | ∀ {α : Type u_1} {c : ℕ} [inst : Lean.Grind.Ring α] [Lean.Grind.IsCharP α c] (ctx : Lean.Grind.CommRing.Context α)
(p₁ p₂ acc : Lean.Grind.CommRing.Poly),
Lean.Grind.CommRing.Poly.denote ctx (Lean.Grind.CommRing.Poly.mulC_nc.go p₂ c p₁ acc) =
Lean.Grind.CommRing.Poly.denote ctx acc +
Lean.Grind.CommRing.P... | null | true |
Lean.Grind.Linarith.Expr.toPoly'.go.eq_7 | Init.Grind.Ordered.Linarith | ∀ (coeff : ℤ) (a : Lean.Grind.Linarith.Expr),
Lean.Grind.Linarith.Expr.toPoly'.go coeff a.neg = Lean.Grind.Linarith.Expr.toPoly'.go (-coeff) a | null | true |
_private.Mathlib.Tactic.ClickSuggestions.0.Mathlib.Tactic.ClickSuggestions.viewKAbstractSubExpr'.match_1 | Mathlib.Tactic.ClickSuggestions | (motive : Option (Lean.Expr × Option ℕ) → Sort u_1) →
(__do_lift : Option (Lean.Expr × Option ℕ)) →
((subExpr : Lean.Expr) → (occ : Option ℕ) → motive (some (subExpr, occ))) →
((x : Option (Lean.Expr × Option ℕ)) → motive x) → motive __do_lift | null | false |
CategoryTheory.Limits.createsColimitsOfShapeOfLeftOp | Mathlib.CategoryTheory.Limits.Preserves.Creates.Opposites | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(J : Type w) →
[inst_2 : CategoryTheory.Category.{w', w} J] →
(F : CategoryTheory.Functor C Dᵒᵖ) →
[CategoryTheory.CreatesLimitsOfShape Jᵒ... | If `F.leftOp : Cᵒᵖ ⥤ D` creates limits of shape `Jᵒᵖ`, then `F : C ⥤ Dᵒᵖ` creates colimits
of shape `J`. | true |
CategoryTheory.evaluation._proof_4 | Mathlib.CategoryTheory.Products.Basic | ∀ (C : Type u_3) [inst : CategoryTheory.Category.{u_1, u_3} C] (D : Type u_4)
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] {x x_1 : C} (f : x ⟶ x_1) ⦃X Y : CategoryTheory.Functor C D⦄
(f_1 : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
({ obj := fun F => F.obj x, map := fun {X Y} α => α.app x, map_id := ⋯,... | null | false |
QPF.Wequiv.abs | Mathlib.Data.QPF.Univariate.Basic | ∀ {F : Type u → Type v} [q : QPF F] (a : (QPF.P F).A) (f : (QPF.P F).B a → (QPF.P F).W) (a' : (QPF.P F).A)
(f' : (QPF.P F).B a' → (QPF.P F).W),
QPF.abs (PFunctor.Obj.mk a f) = QPF.abs (PFunctor.Obj.mk a' f') → QPF.Wequiv (WType.mk a f) (WType.mk a' f') | null | true |
_private.Mathlib.Analysis.CStarAlgebra.ApproximateUnit.0.Set.InvOn.one_sub_one_add_inv._simp_1_1 | Mathlib.Analysis.CStarAlgebra.ApproximateUnit | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
Lean.Parser.Error.mk.sizeOf_spec | Lean.Parser.Types | ∀ (unexpectedTk : Lean.Syntax) (unexpected : String) (expected : List String),
sizeOf { unexpectedTk := unexpectedTk, unexpected := unexpected, expected := expected } =
1 + sizeOf unexpectedTk + sizeOf unexpected + sizeOf expected | null | true |
_private.Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme.0.AlgebraicGeometry.Scheme.instFullOppositeIdealSheafDataOverSubschemeFunctor._simp_2 | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (h : X = Y),
CategoryTheory.IsIso (CategoryTheory.eqToHom h) = True | null | false |
_private.Std.Do.Triple.SpecLemmas.0.Std.Do.Spec.throw_ExceptT._simp_1_1 | Std.Do.Triple.SpecLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} [inst : Std.Do.WP m ps] {α : Type u} {x : m α} {P : Std.Do.Assertion ps}
{Q : Std.Do.PostCond α ps}, ⦃P⦄ x ⦃Q⦄ = (P ⊢ₛ (Std.Do.wp x).apply Q) | null | false |
Set.Icc.coe_nonneg | Mathlib.Algebra.Order.Interval.Set.Instances | ∀ {R : Type u_1} [inst : Zero R] [inst_1 : One R] [inst_2 : Preorder R] (x : ↑(Set.Icc 0 1)), 0 ≤ ↑x | null | true |
Matrix.single_apply_of_col_ne | Mathlib.Data.Matrix.Basis | ∀ {m : Type u_2} {n : Type u_3} {α : Type u_7} [inst : DecidableEq m] [inst_1 : DecidableEq n] [inst_2 : Zero α]
(i i' : m) {j j' : n}, j ≠ j' → ∀ (a : α), Matrix.single i j a i' j' = 0 | null | true |
isPreirreducible_singleton | Mathlib.Topology.Irreducible | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x : X}, IsPreirreducible {x} | null | true |
_private.Mathlib.Tactic.GRewrite.Core.0.Mathlib.Tactic.GRewrite.GRewriteLemma.index | Mathlib.Tactic.GRewrite.Core | Mathlib.Tactic.GRewrite.GRewriteLemma✝ → Lean.HeadIndex × ℕ | The key used to determine where to attempt rewriting. | true |
CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._proof_53 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ (r₀ r r' : ℤ),
autoParam (r + 1 = r') CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_47 →
autoParam (r₀ ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_49 → r₀ ≤ r' | null | false |
continuousOn_stereoToFun | Mathlib.Geometry.Manifold.Instances.Sphere | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] {v : E},
ContinuousOn (stereoToFun v) {x | ((innerSL ℝ) v) x ≠ 1} | null | true |
CategoryTheory.Oplax.OplaxTrans.Modification.noConfusion | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | {P : Sort u} →
{B : Type u₁} →
{inst : CategoryTheory.Bicategory B} →
{C : Type u₂} →
{inst_1 : CategoryTheory.Bicategory C} →
{F G : CategoryTheory.OplaxFunctor B C} →
{η θ : F ⟶ G} →
{t : CategoryTheory.Oplax.OplaxTrans.Modification η θ} →
{B' : ... | null | false |
Lean.Data.Trie.empty | Lean.Data.Trie | {α : Type} → Lean.Data.Trie α | The empty `Trie` | true |
Lean.Meta.Grind.Arith.CommRing.RingM.Context.rec | Lean.Meta.Tactic.Grind.Arith.CommRing.RingM | {motive : Lean.Meta.Grind.Arith.CommRing.RingM.Context → Sort u} →
((ringId : ℕ) → (checkCoeffDvd : Bool) → motive { ringId := ringId, checkCoeffDvd := checkCoeffDvd }) →
(t : Lean.Meta.Grind.Arith.CommRing.RingM.Context) → motive t | null | false |
Real.sqrt_inj._simp_1 | Mathlib.Analysis.Real.Sqrt | ∀ {x y : ℝ}, 0 ≤ x → 0 ≤ y → (√x = √y) = (x = y) | null | false |
Aesop.RuleTacDescr.cases.noConfusion | Aesop.RuleTac.Descr | {P : Sort u} →
{target : Aesop.CasesTarget} →
{md : Lean.Meta.TransparencyMode} →
{isRecursiveType : Bool} →
{ctorNames : Array Aesop.CtorNames} →
{target' : Aesop.CasesTarget} →
{md' : Lean.Meta.TransparencyMode} →
{isRecursiveType' : Bool} →
{cto... | null | false |
instLEClass._aux_1 | Mathlib.SetTheory.ZFC.Class | Class.{u_1} → Class.{u_1} → Prop | null | false |
CategoryTheory.ObjectProperty.InheritedFromSource.instMin | Mathlib.CategoryTheory.ObjectProperty.InheritedFromHom | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (P P' : CategoryTheory.ObjectProperty C)
(Q : CategoryTheory.MorphismProperty C) [P.InheritedFromSource Q] [P'.InheritedFromSource Q],
(P ⊓ P').InheritedFromSource Q | null | true |
Vector.set | Init.Data.Vector.Basic | {α : Type u_1} → {n : ℕ} → Vector α n → (i : ℕ) → α → autoParam (i < n) Vector.set._auto_1 → Vector α n | Set an element in a vector using a `Nat` index, with a tactic provided proof that the index is in
bounds.
This will perform the update destructively provided that the vector has a reference count of 1.
| true |
_private.Mathlib.Probability.Distributions.Fernique.0.ProbabilityTheory.exists_integrable_exp_sq_of_map_rotation_eq_self_of_isProbabilityMeasure._simp_1_2 | Mathlib.Probability.Distributions.Fernique | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | null | false |
CategoryTheory.Cat.freeRefl_map | Mathlib.CategoryTheory.Category.ReflQuiv | ∀ {X Y : CategoryTheory.ReflQuiv} (F : X ⟶ Y),
CategoryTheory.Cat.freeRefl.map F = (CategoryTheory.Cat.freeReflMap F).toCatHom | null | true |
CategoryTheory.MorphismProperty.equivalenceLeftFractionRel | Mathlib.CategoryTheory.Localization.CalculusOfFractions | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (W : CategoryTheory.MorphismProperty C)
[W.HasLeftCalculusOfFractions] (X Y : C), Equivalence CategoryTheory.MorphismProperty.LeftFractionRel | null | true |
ValuationSubring.instFieldSubtypeMemTop._proof_19 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u_1} [inst : Field K] (a : ℚ) (a_1 : ↥⊤), a • ↑a_1 ∈ ⊤ | null | false |
instInvInterval | Mathlib.Algebra.Order.Interval.Basic | {α : Type u_2} → [inst : CommGroup α] → [inst_1 : PartialOrder α] → [IsOrderedMonoid α] → Inv (Interval α) | null | true |
Lean.Lsp.TextDocumentSyncOptions.rec | Lean.Data.Lsp.TextSync | {motive : Lean.Lsp.TextDocumentSyncOptions → Sort u} →
((openClose : Bool) →
(change : Lean.Lsp.TextDocumentSyncKind) →
(willSave willSaveWaitUntil : Bool) →
(save? : Option Lean.Lsp.SaveOptions) →
motive
{ openClose := openClose, change := change, willSave := willSav... | null | false |
Std.Internal.List.containsKey_iff_exists | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [PartialEquivBEq α] {l : List ((a : α) × β a)} {a : α},
Std.Internal.List.containsKey a l = true ↔ ∃ a' ∈ Std.Internal.List.keys l, (a == a') = true | null | true |
QuadraticModuleCat.instMonoidalCategory.tensorHom | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat.Monoidal | {R : Type u} →
[inst : CommRing R] →
[inst_1 : Invertible 2] →
{W X Y Z : QuadraticModuleCat R} →
(W ⟶ X) →
(Y ⟶ Z) →
(QuadraticModuleCat.instMonoidalCategory.tensorObj W Y ⟶
QuadraticModuleCat.instMonoidalCategory.tensorObj X Z) | Auxiliary definition used to build `QuadraticModuleCat.instMonoidalCategory`.
We want this up front so that we can re-use it to define `whiskerLeft` and `whiskerRight`. | true |
CategoryTheory.Equalizer.Sieve.SecondObj.ext | Mathlib.CategoryTheory.Sites.EqualizerSheafCondition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.Functor Cᵒᵖ (Type (max v u))} {X : C}
{S : CategoryTheory.Sieve X} (z₁ z₂ : CategoryTheory.Equalizer.Sieve.SecondObj P S),
(∀ (Y Z : C) (g : Z ⟶ Y) (f : Y ⟶ X) (hf : S.arrows f),
(CategoryTheory.ConcreteCategory.hom
(Cate... | null | true |
_private.Mathlib.RingTheory.MvPowerSeries.Order.0.MvPowerSeries.coeff_mul_prod_one_sub_of_lt_weightedOrder._simp_1_1 | Mathlib.RingTheory.MvPowerSeries.Order | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a b : α}, (a ∈ insert b s) = (a = b ∨ a ∈ s) | null | false |
Ideal.mulQuot | Mathlib.RingTheory.OrderOfVanishing.Basic | {R : Type u_1} → [inst : CommRing R] → (a : R) → (I : Ideal R) → R ⧸ I →ₗ[R] R ⧸ a • I | The map `R ⧸ I →ₗ[R] R ⧸ (a • I)` defined by multiplication by `a`
| true |
Filter.comap_lift_eq | Mathlib.Order.Filter.Lift | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {g : Set α → Filter β} {m : γ → β},
Filter.comap m (f.lift g) = f.lift (Filter.comap m ∘ g) | null | true |
Filter.Germ.const_lt_iff | Mathlib.Order.Filter.FilterProduct | ∀ {α : Type u} {β : Type v} {φ : Ultrafilter α} [inst : Preorder β] {x y : β}, ↑x < ↑y ↔ x < y | null | true |
FormalMultilinearSeries.rightInv._proof_16 | Mathlib.Analysis.Analytic.Inverse | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F], ContinuousConstSMul 𝕜 F | null | false |
CategoryTheory.Comonad.ForgetCreatesLimits'.newCone_pt | Mathlib.CategoryTheory.Monad.Limits | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [inst_1 : CategoryTheory.Category.{v, u} J]
{T : CategoryTheory.Comonad C} {D : CategoryTheory.Functor J T.Coalgebra}
(c : CategoryTheory.Limits.Cone (D.comp T.forget)), (CategoryTheory.Comonad.ForgetCreatesLimits'.newCone c).pt = c.pt | null | true |
_private.Mathlib.RingTheory.PowerSeries.Schroder.0.PowerSeries.coeff_X_mul_largeSchroderSeries._simp_1_1 | Mathlib.RingTheory.PowerSeries.Schroder | ∀ {n m : ℕ}, (m ∈ Finset.range n) = (m < n) | null | false |
Lean.Grind.Linarith.Poly.NonnegCoeffs.brecOn | Init.Grind.Module.NatModuleNorm | ∀ {motive : (a : Lean.Grind.Linarith.Poly) → a.NonnegCoeffs → Prop} {a : Lean.Grind.Linarith.Poly} (t : a.NonnegCoeffs),
(∀ (a : Lean.Grind.Linarith.Poly) (t : a.NonnegCoeffs), Lean.Grind.Linarith.Poly.NonnegCoeffs.below t → motive a t) →
motive a t | null | true |
Lean.Meta.Sym.Arith.ClassifyResult.ctorElim | Lean.Meta.Sym.Arith.Types | {motive : Lean.Meta.Sym.Arith.ClassifyResult → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Meta.Sym.Arith.ClassifyResult) →
ctorIdx = t.ctorIdx → Lean.Meta.Sym.Arith.ClassifyResult.ctorElimType ctorIdx → motive t | null | false |
MeasureTheory.lintegral_prod_mul | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {μ : MeasureTheory.Measure α}
{ν : MeasureTheory.Measure β} [MeasureTheory.SFinite ν] {f : α → ENNReal} {g : β → ENNReal},
AEMeasurable f μ →
AEMeasurable g ν → ∫⁻ (z : α × β), f z.1 * g z.2 ∂μ.prod ν = (∫⁻ (x : α), f x ∂μ) ... | null | true |
Asymptotics.isBigO_const_mul_self | Mathlib.Analysis.Asymptotics.Ring | ∀ {α : Type u_1} {R : Type u_4} [inst : SeminormedRing R] (c : R) (f : α → R) (l : Filter α), (fun x => c * f x) =O[l] f | null | true |
Batteries.Tactic.Lint.LintVerbosity._sizeOf_1 | Batteries.Tactic.Lint.Frontend | Batteries.Tactic.Lint.LintVerbosity → ℕ | null | false |
CategoryTheory.Lax.LaxTrans.LaxFunctor.bicategory_associator_inv_as_app | Mathlib.CategoryTheory.Bicategory.FunctorBicategory.Lax | ∀ (B : Type u₁) [inst : CategoryTheory.Bicategory B] (C : Type u₂) [inst_1 : CategoryTheory.Bicategory C]
{x x_1 x_2 : CategoryTheory.LaxFunctor B C} (x_3 : CategoryTheory.LaxFunctor B C) (η : x ⟶ x_1) (θ : x_1 ⟶ x_2)
(ι : x_2 ⟶ x_3) (a : B),
(CategoryTheory.Bicategory.associator η θ ι).inv.as.app a =
(Catego... | null | true |
_private.Mathlib.CategoryTheory.Triangulated.Orthogonal.0.CategoryTheory.ObjectProperty.isLocal_trW._simp_1_3 | Mathlib.CategoryTheory.Triangulated.Orthogonal | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
completeBipartiteGraph | Mathlib.Combinatorics.SimpleGraph.Basic | (V : Type u_1) → (W : Type u_2) → SimpleGraph (V ⊕ W) | Two vertices are adjacent in the complete bipartite graph on two vertex types
if and only if they are not from the same side.
Any bipartite graph may be regarded as a subgraph of one of these. | true |
Int.neg_add_le_right_of_le_add | Init.Data.Int.Order | ∀ {a b c : ℤ}, a ≤ b + c → -c + a ≤ b | null | true |
_private.Init.Data.Option.Monadic.0.Option.instForIn'InferInstanceMembershipOfMonad.match_1.splitter | Init.Data.Option.Monadic | {β : Type u_1} →
(motive : ForInStep β → Sort u_2) →
(__do_lift : ForInStep β) →
((r : β) → motive (ForInStep.done r)) → ((r : β) → motive (ForInStep.yield r)) → motive __do_lift | null | true |
Aesop.PostponedSafeRule.ctorIdx | Aesop.Tree.UnsafeQueue | Aesop.PostponedSafeRule → ℕ | null | false |
_private.Mathlib.Topology.Order.LeftRightLim.0.tendsto_atTop_of_mapClusterPt._simp_1_1 | Mathlib.Topology.Order.LeftRightLim | ∀ {α : Type u_3} [inst : Preorder α] [IsDirectedOrder α] {p : α → Prop} [Nonempty α],
(∀ᶠ (x : α) in Filter.atTop, p x) = ∃ a, ∀ (b : α), a ≤ b → p b | null | false |
Mathlib.Meta.NormNum.NotPowerCertificate.mk.injEq | Mathlib.Tactic.NormNum.Irrational | ∀ {m n : Q(ℕ)} (k : Q(ℕ)) (pf_left : Q(«$k» ^ «$n» < «$m»)) (pf_right : Q(«$m» < («$k» + 1) ^ «$n»)) (k_1 : Q(ℕ))
(pf_left_1 : Q(«$k_1» ^ «$n» < «$m»)) (pf_right_1 : Q(«$m» < («$k_1» + 1) ^ «$n»)),
({ k := k, pf_left := pf_left, pf_right := pf_right } = { k := k_1, pf_left := pf_left_1, pf_right := pf_right_1 }) =
... | null | true |
Mathlib.Tactic.IntervalCases.Bound.lt.injEq | Mathlib.Tactic.IntervalCases | ∀ (n n_1 : ℤ), (Mathlib.Tactic.IntervalCases.Bound.lt n = Mathlib.Tactic.IntervalCases.Bound.lt n_1) = (n = n_1) | null | true |
SimpleGraph.IsContained.of_isEmpty._simp_1 | Mathlib.Combinatorics.SimpleGraph.Copy | ∀ {V : Type u_1} {W : Type u_2} {G : SimpleGraph V} {H : SimpleGraph W} [IsEmpty W], Nonempty (H.Copy G) = True | null | false |
CategoryTheory.Grothendieck.Hom.noConfusionType | Mathlib.CategoryTheory.Grothendieck | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor C CategoryTheory.Cat} →
{X Y : CategoryTheory.Grothendieck F} →
X.Hom Y →
{C' : Type u} →
[inst' : CategoryTheory.Category.{v, u} C'] →
{F' : Category... | null | false |
_private.Mathlib.Algebra.Homology.Homotopy.0.Homotopy.toShortComplex._abel_3 | Mathlib.Algebra.Homology.Homotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {ι : Type u_3}
{c : ComplexShape ι} {K L : HomologicalComplex C c} {f g : K ⟶ L} (ho : Homotopy f g) (i : ι),
f.f (c.prev i) =
CategoryTheory.CategoryStruct.comp (K.d (c.prev i) i) (ho.hom i (c.prev i)) +
... | null | false |
_private.Mathlib.RingTheory.Filtration.0.Ideal.Filtration.Stable.exists_pow_smul_eq._proof_1_1 | Mathlib.RingTheory.Filtration | ∀ (n₀ n : ℕ), n₀ ≤ n₀ + n | null | false |
_private.Init.Data.Nat.Power2.Basic.0.Nat.nextPowerOfTwo.go._proof_1 | Init.Data.Nat.Power2.Basic | ∀ power > 0, 0 < power * 2 | null | false |
Lean.Compiler.LCNF.Code.setTag.inj | Lean.Compiler.LCNF.Basic | ∀ {pu : Lean.Compiler.LCNF.Purity} {fvarId : Lean.FVarId} {cidx : ℕ} {k : Lean.Compiler.LCNF.Code pu}
{h : autoParam (pu = Lean.Compiler.LCNF.Purity.impure) Lean.Compiler.LCNF.Alt._auto_13} {fvarId_1 : Lean.FVarId}
{cidx_1 : ℕ} {k_1 : Lean.Compiler.LCNF.Code pu}
{h_1 : autoParam (pu = Lean.Compiler.LCNF.Purity.im... | null | true |
WithZero.instCoeTC.eq_1 | Mathlib.Algebra.Group.WithOne.Defs | ∀ {α : Type u}, WithZero.instCoeTC = { coe := WithZero.coe } | null | true |
MeasureTheory.eLpNorm_le_eLpNorm_mul_eLpNorm_of_nnnorm | Mathlib.MeasureTheory.Function.LpSeminorm.CompareExp | ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} {m : MeasurableSpace α} [inst : NormedAddCommGroup E]
[inst_1 : NormedAddCommGroup F] [inst_2 : NormedAddCommGroup G] {μ : MeasureTheory.Measure α} {f : α → E} {g : α → F}
{p q r : ENNReal} (b : E → F → G) (c : NNReal),
Continuous (Function.uncurry b) ... | **Alias** of `MeasureTheory.eLpNorm_le_eLpNorm_mul_eLpNorm`. | true |
QuadraticAlgebra.baseChangeEquiv.eq_1 | Mathlib.Algebra.QuadraticAlgebra.BaseChange | ∀ {R : Type u_1} (S : Type u_2) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (a b : R),
QuadraticAlgebra.baseChangeEquiv S a b =
Algebra.IsPushout.equiv R S (QuadraticAlgebra R a b) (QuadraticAlgebra S ((algebraMap R S) a) ((algebraMap R S) b)) | null | true |
AffineSubspace.mem_perpBisector_iff_inner_eq_inner | Mathlib.Geometry.Euclidean.PerpBisector | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {c p₁ p₂ : P},
c ∈ AffineSubspace.perpBisector p₁ p₂ ↔ inner ℝ (c -ᵥ p₁) (p₂ -ᵥ p₁) = inner ℝ (c -ᵥ p₂) (p₁ -ᵥ p₂) | null | true |
Part.some_sdiff_some | Mathlib.Data.Part | ∀ {α : Type u_1} [inst : SDiff α] (a b : α), Part.some a \ Part.some b = Part.some (a \ b) | null | true |
AlgCat.instMonoidalCategory.tensorHom._proof_1 | Mathlib.Algebra.Category.AlgCat.Monoidal | ∀ {R : Type u_1} [inst : CommRing R] {W : AlgCat R}, IsScalarTower R R ↑W | null | false |
_private.Mathlib.Order.CountableDenseLinearOrder.0.Order.exists_orderEmbedding_insert._simp_1_3 | Mathlib.Order.CountableDenseLinearOrder | ∀ {α : Type u_1} (s : Finset α) (x : ↥s), (x ∈ s.attach) = True | null | false |
Sum.bnot_isRight | Init.Data.Sum.Lemmas | ∀ {α : Type u_1} {β : Type u_2} (x : α ⊕ β), (!x.isRight) = x.isLeft | null | true |
Valuation.norm._proof_1 | Mathlib.Topology.Algebra.Valued.NormedValued | ∀ {Γ₀ : Type u_1} [inst : LinearOrderedCommGroupWithZero Γ₀], SubmonoidClass (Subgroup Γ₀ˣ) Γ₀ˣ | null | false |
Std.DTreeMap.Raw.get!.congr_simp | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} [inst : Std.LawfulEqCmp cmp]
(t t_1 : Std.DTreeMap.Raw α β cmp), t = t_1 → ∀ (a : α) [inst_1 : Inhabited (β a)], t.get! a = t_1.get! a | null | true |
_private.Mathlib.RingTheory.Polynomial.Eisenstein.IsIntegral.0._aux_Mathlib_RingTheory_Polynomial_Eisenstein_IsIntegral___macroRules__private_Mathlib_RingTheory_Polynomial_Eisenstein_IsIntegral_0_term𝓟_1_1 | Mathlib.RingTheory.Polynomial.Eisenstein.IsIntegral | Lean.Macro | null | false |
_private.Mathlib.Topology.MetricSpace.Pseudo.Constructions.0.sphere_prod._simp_1_5 | Mathlib.Topology.MetricSpace.Pseudo.Constructions | ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, (max a b = c) = (a = c ∧ b ≤ a ∨ b = c ∧ a ≤ b) | null | false |
Batteries.Tactic.TransRelation.implies.elim | Batteries.Tactic.Trans | {motive : Batteries.Tactic.TransRelation → Sort u} →
(t : Batteries.Tactic.TransRelation) →
t.ctorIdx = 1 →
((name : Lean.Name) → (bi : Lean.BinderInfo) → motive (Batteries.Tactic.TransRelation.implies name bi)) → motive t | null | false |
IncidenceAlgebra.lambda_apply | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ (𝕜 : Type u_1) {α : Type u_4} [inst : Zero 𝕜] [inst_1 : One 𝕜] [inst_2 : Preorder α]
[inst_3 : DecidableRel fun x1 x2 => x1 ⩿ x2] (a b : α), (IncidenceAlgebra.lambda 𝕜) a b = if a ⩿ b then 1 else 0 | null | true |
_private.Lean.ToExpr.0.Lean.Name.toExprAux.isSimple._unsafe_rec | Lean.ToExpr | Lean.Name → ℕ → Bool | null | false |
Valuation.RankOne.toRankLeOne | Mathlib.RingTheory.Valuation.RankOne | {R : Type u_1} →
{Γ₀ : Type u_2} →
{inst : Ring R} →
{inst_1 : LinearOrderedCommGroupWithZero Γ₀} → {v : Valuation R Γ₀} → [self : v.RankOne] → v.RankLeOne | null | true |
Ordinal.lt_add_iff | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ {a b c : Ordinal.{u_4}}, c ≠ 0 → (a < b + c ↔ ∃ d < c, a ≤ b + d) | null | true |
FreeMonoid.count_apply | Mathlib.Algebra.FreeMonoid.Count | ∀ {α : Type u_1} [inst : DecidableEq α] (x : α) (l : FreeAddMonoid α),
(FreeMonoid.count x) l = Multiplicative.ofAdd (List.count x (FreeAddMonoid.toList l)) | null | true |
AddGroupWithOne.noConfusionType | Mathlib.Data.Int.Cast.Defs | Sort u_1 → {R : Type u} → AddGroupWithOne R → {R' : Type u} → AddGroupWithOne R' → Sort u_1 | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getD_diff_of_contains_eq_false_right._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) | null | false |
Complex.cosh_ofReal_im | Mathlib.Analysis.Complex.Trigonometric | ∀ (x : ℝ), (Complex.cosh ↑x).im = 0 | null | true |
CategoryTheory.MorphismProperty.FunctorialFactorizationData.functorCategory._proof_4 | Mathlib.CategoryTheory.MorphismProperty.Factorization | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {W₁ W₂ : CategoryTheory.MorphismProperty C}
(data : W₁.FunctorialFactorizationData W₂) (J : Type u_1) [inst_1 : CategoryTheory.Category.{u_4, u_1} J]
⦃X Y : CategoryTheory.Arrow (CategoryTheory.Functor J C)⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.... | null | false |
Std.HashMap.getKey_eq_getKeyD | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{a fallback : α} {h' : a ∈ m}, m.getKey a h' = m.getKeyD a fallback | null | true |
Fin.orderPred_zero | Mathlib.Order.SuccPred.Fin | ∀ (n : ℕ), Order.pred 0 = 0 | null | true |
CoxeterMatrix.recOn | Mathlib.GroupTheory.Coxeter.Matrix | {B : Type u_1} →
{motive : CoxeterMatrix B → Sort u} →
(t : CoxeterMatrix B) →
((M : Matrix B B ℕ) →
(isSymm : M.IsSymm) →
(diagonal : ∀ (i : B), M i i = 1) →
(off_diagonal : ∀ (i i' : B), i ≠ i' → M i i' ≠ 1) →
motive { M := M, isSymm := isSymm, diagonal ... | null | false |
CategoryTheory.Mat_.instPreadditive._proof_2 | Mathlib.CategoryTheory.Preadditive.Mat | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(M N K : CategoryTheory.Mat_ C) (f : M ⟶ N) (g g' : N ⟶ K),
CategoryTheory.CategoryStruct.comp f (g + g') =
CategoryTheory.CategoryStruct.comp f g + CategoryTheory.CategoryStruct.comp f g' | null | false |
Std.CloseableChannel.Flavors._sizeOf_1 | Std.Sync.Channel | {α : Type} → [SizeOf α] → Std.CloseableChannel.Flavors α → ℕ | null | false |
Matrix._aux_Mathlib_LinearAlgebra_Matrix_GeneralLinearGroup_Defs___unexpand_Matrix_GeneralLinearGroup_1 | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.Defs | Lean.PrettyPrinter.Unexpander | null | false |
_private.Mathlib.Order.OmegaCompletePartialOrder.0.OmegaCompletePartialOrder.isLUB_range_ωSup._simp_1_2 | Mathlib.Order.OmegaCompletePartialOrder | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.