name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastRotateRight.go_get_aux._proof_1_3 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight | ∀ {w : ℕ}, ∀ curr ≤ w, ∀ (idx : ℕ), ¬curr < w → ¬curr = w → False | null | false |
Std.Sat.AIG.RefVec.get_cast | Std.Sat.AIG.RefVec | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {len : ℕ} {aig1 aig2 : Std.Sat.AIG α} (s : aig1.RefVec len)
(idx : ℕ) (hidx : idx < len) (hcast : aig1.decls.size ≤ aig2.decls.size),
(s.cast hcast).get idx hidx = (s.get idx hidx).cast hcast | null | true |
Lean.Meta.Tactic.TryThis.addExactSuggestions | Lean.Meta.Tactic.TryThis | Lean.Syntax →
Array Lean.Expr →
optParam (Option Lean.Syntax) none →
optParam Bool false →
optParam (Option String) none →
optParam (Option Lean.Elab.Tactic.SavedState) none → optParam Bool true → Lean.Elab.Tactic.TacticM Unit | Add `exact e` or `refine e` suggestions if they can be successfully generated; for those that
cannot, display messages indicating the invalid generated tactics.
The parameters are:
* `ref`: the span of the widget diagnostic
* `es`: the array of replacement expressions
* `origSpan?`: a syntax object whose span is the a... | true |
Commute.geom_sum₂_Ico | Mathlib.Algebra.Field.GeomSum | ∀ {K : Type u_2} [inst : DivisionRing K] {x y : K},
Commute x y →
x ≠ y → ∀ {m n : ℕ}, m ≤ n → ∑ i ∈ Finset.Ico m n, x ^ i * y ^ (n - 1 - i) = (x ^ n - y ^ (n - m) * x ^ m) / (x - y) | null | true |
Lean.getProjFnInfoForField? | Lean.Structure | Lean.Environment → Lean.Name → Lean.Name → Option (Lean.Name × Lean.ProjectionFunctionInfo) | null | true |
_private.Init.Data.Range.Polymorphic.SInt.0.Int8.instUpwardEnumerable._proof_3 | Init.Data.Range.Polymorphic.SInt | ∀ (n : ℕ) (i : Int8), i.toInt + ↑n ≤ Int8.maxValueSealed✝.toInt → i.toInt + ↑n ≤ Int8.maxValue.toInt | null | false |
CategoryTheory.projectiveDimension_lt_iff | Mathlib.CategoryTheory.Abelian.Projective.Dimension | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {X : C} {n : ℕ},
CategoryTheory.projectiveDimension X < ↑n ↔ CategoryTheory.HasProjectiveDimensionLT X n | null | true |
Lean.Parser.Term.termTry | Lean.Parser.Do | Lean.Parser.Parser | null | true |
Mathlib.Tactic.ClickSuggestions.SectionKind.currFile.sizeOf_spec | Mathlib.Tactic.ClickSuggestions.SectionState | sizeOf Mathlib.Tactic.ClickSuggestions.SectionKind.currFile = 1 | null | true |
_private.Mathlib.Analysis.Normed.Algebra.GelfandMazur.0.NormedAlgebra.Real.φ | Mathlib.Analysis.Normed.Algebra.GelfandMazur | {F : Type u_1} → [inst : NormedRing F] → [NormedAlgebra ℝ F] → F → ℝ × ℝ → F | A (private) abbreviation introduced for conciseness below.
We will show that for every `x : F`, `φ x` takes the value zero. | true |
IsGroupLikeElem.antipode._simp_1 | Mathlib.RingTheory.HopfAlgebra.GroupLike | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : HopfAlgebra R A] {a : A},
IsGroupLikeElem R a → IsGroupLikeElem R ((HopfAlgebraStruct.antipode R) a) = True | null | false |
_private.Lean.Elab.Tactic.Do.ProofMode.Cases.0.Lean.Elab.Tactic.Do.ProofMode.mCasesCore._sparseCasesOn_6 | Lean.Elab.Tactic.Do.ProofMode.Cases | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
ExceptT.bindCont.eq_2 | Init.Control.Lawful.Instances | ∀ {ε : Type u} {m : Type u → Type v} [inst : Monad m] {α β : Type u} (f : α → ExceptT ε m β) (e : ε),
ExceptT.bindCont f (Except.error e) = pure (Except.error e) | null | true |
ContinuousLinearMap.norm_smulRightL_le | Mathlib.Analysis.Normed.Operator.NormedSpace | ∀ {𝕜 : Type u_1} {E : Type u_5} {Fₗ : Type u_7} [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup Fₗ]
[inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NormedSpace 𝕜 E] [inst_4 : NormedSpace 𝕜 Fₗ],
‖ContinuousLinearMap.smulRightL 𝕜 E Fₗ‖ ≤ 1 | null | true |
intervalIntegral.derivWithin_integral_of_tendsto_ae_left._auto_1 | Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | Lean.Syntax | null | false |
Orientation.kahler_map | Mathlib.Analysis.InnerProductSpace.TwoDim | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] [inst_2 : Fact (Module.finrank ℝ E = 2)]
(o : Orientation ℝ E (Fin 2)) {F : Type u_2} [inst_3 : NormedAddCommGroup F] [inst_4 : InnerProductSpace ℝ F]
[hF : Fact (Module.finrank ℝ F = 2)] (φ : E ≃ₗᵢ[ℝ] F) (x y : F),
(((Orientation.map... | null | true |
Lean.Meta.Simp.getSimprocFromDeclImpl | Lean.Meta.Tactic.Simp.Simproc | Lean.Name → Lean.ImportM (Lean.Meta.Simp.Simproc ⊕ Lean.Meta.Simp.DSimproc) | null | true |
Lean.Elab.Tactic.Grind.SimpCacheKey.noConfusionType | Lean.Elab.Tactic.Grind.Basic | Sort u → Lean.Elab.Tactic.Grind.SimpCacheKey → Lean.Elab.Tactic.Grind.SimpCacheKey → Sort u | null | false |
_private.Mathlib.CategoryTheory.WithTerminal.Cone.0.CategoryTheory.WithTerminal.coneBack_obj_π_app | Mathlib.CategoryTheory.WithTerminal.Cone | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : Type w} [inst_1 : CategoryTheory.Category.{w', w} J]
{X : C} {K : CategoryTheory.Functor J (CategoryTheory.Over X)}
(t : CategoryTheory.Limits.Cone (CategoryTheory.WithTerminal.liftFromOver.obj K)) (a : J),
(CategoryTheory.WithTerminal.coneBack✝.obj... | null | true |
GrpTypeEquivalenceGrp.inverse._proof_1 | Mathlib.CategoryTheory.Monoidal.Internal.Types.Grp | ∀ (A : GrpCat),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CartesianMonoidalCategory.lift (TypeCat.ofHom fun x => x⁻¹)
(CategoryTheory.CategoryStruct.id
(MonTypeEquivalenceMon.inverse.obj ((CategoryTheory.forget₂ GrpCat MonCat).obj A)).X))
CategoryTheory.MonObj.mul =
Category... | null | false |
Finset.prod_insert' | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_1} {M : Type u_4} {s : Finset ι} {a : ι} [inst : CommMonoid M] [inst_1 : DecidableEq ι],
a ∉ s → (insert a s).prod = fun f => f a * ∏ x ∈ s, f x | Variant of `prod_insert` not applied to a function. | true |
_private.Std.Http.Data.Headers.Basic.0.Std.Http.Header.instBEqHost.beq.match_1 | Std.Http.Data.Headers.Basic | (motive : Std.Http.Header.Host → Std.Http.Header.Host → Sort u_1) →
(x x_1 : Std.Http.Header.Host) →
((a : Std.Http.URI.Host) →
(a_1 : Std.Http.URI.Port) →
(b : Std.Http.URI.Host) →
(b_1 : Std.Http.URI.Port) → motive { host := a, port := a_1 } { host := b, port := b_1 }) →
((x ... | null | false |
Fin.castSucc_lt_last._simp_2 | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} (a : Fin n), (a.castSucc < Fin.last n) = True | null | false |
Aesop.SaturateM.Context.noConfusionType | Aesop.Saturate | Sort u → Aesop.SaturateM.Context → Aesop.SaturateM.Context → Sort u | null | false |
SSet.innerFibrations | Mathlib.AlgebraicTopology.Quasicategory.InnerFibration | CategoryTheory.MorphismProperty SSet | The inner fibrations are the morphisms which have the right lifting property
with respect to inner horn inclusions. | true |
ProofWidgets.InteractiveCodeProps.noConfusionType | ProofWidgets.Component.Basic | Sort u → ProofWidgets.InteractiveCodeProps → ProofWidgets.InteractiveCodeProps → Sort u | null | false |
_private.Lean.Parser.Extra.0.Lean.Parser.ppRealGroup._regBuiltin.Lean.Parser.ppRealGroup.docString_1 | Lean.Parser.Extra | IO Unit | null | false |
CategoryTheory.rightDistributor_ext₂_right | Mathlib.CategoryTheory.Monoidal.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.MonoidalCategory C] [CategoryTheory.MonoidalPreadditive C]
[inst_4 : CategoryTheory.Limits.HasFiniteBiproducts C] {J : Type} [inst_5 : Finite J] {f : J → C} {X Y Z : C}
{g h :
X ⟶ Ca... | null | true |
Padic.AddValuation.map_zero | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)], Padic.addValuationDef 0 = ⊤ | null | true |
LinearMap.BilinForm.dualSubmoduleToDual._proof_11 | Mathlib.LinearAlgebra.BilinearForm.DualLattice | ∀ {R : Type u_2} {S : Type u_3} {M : Type u_1} [inst : CommRing R] [inst_1 : Field S] [inst_2 : AddCommGroup M]
[inst_3 : Algebra R S] [inst_4 : Module R M] [inst_5 : Module S M] [inst_6 : IsScalarTower R S M]
(B : LinearMap.BilinForm S M) [IsDomain R] [Module.IsTorsionFree R S] (N : Submodule R M) (r : R)
(x : ↥... | null | false |
Nat.eq_sub_of_add_eq' | Init.Data.Nat.Lemmas | ∀ {a b c : ℕ}, b + c = a → c = a - b | null | true |
_private.Mathlib.CategoryTheory.Localization.Monoidal.Basic.0.CategoryTheory.Localization.Monoidal._aux_Mathlib_CategoryTheory_Localization_Monoidal_Basic___macroRules__private_Mathlib_CategoryTheory_Localization_Monoidal_Basic_0_CategoryTheory_Localization_Monoidal_termL'_1 | Mathlib.CategoryTheory.Localization.Monoidal.Basic | Lean.Macro | null | false |
Matrix.GeneralLinearGroup.congr_simp | Mathlib.Analysis.Complex.UpperHalfPlane.FixedPoints | ∀ (n : Type u) (R : Type v) {inst : DecidableEq n} [inst_1 : DecidableEq n] [inst_2 : Fintype n] [inst_3 : Semiring R],
GL n R = GL n R | null | true |
Lean.Lsp.ParameterInformationLabel.name.inj | Lean.Data.Lsp.LanguageFeatures | ∀ {name name_1 : String},
Lean.Lsp.ParameterInformationLabel.name name = Lean.Lsp.ParameterInformationLabel.name name_1 → name = name_1 | null | true |
CompactExhaustion._sizeOf_inst | Mathlib.Topology.Compactness.SigmaCompact | (X : Type u_4) → {inst : TopologicalSpace X} → [SizeOf X] → SizeOf (CompactExhaustion X) | null | false |
DirichletCharacter.changeLevel._proof_1 | Mathlib.NumberTheory.DirichletCharacter.Basic | ∀ {R : Type u_1} [inst : CommMonoidWithZero R] {n m : ℕ} (hm : n ∣ m),
MulChar.ofUnitHom ((MulChar.toUnitHom 1).comp (ZMod.unitsMap hm)) = 1 | null | false |
Orientation.areaForm'._proof_12 | Mathlib.Analysis.InnerProductSpace.TwoDim | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E], ContinuousSMul ℝ (E →L[ℝ] ℝ) | null | false |
_private.Mathlib.Algebra.Group.Center.0.Set.center_prod._simp_1_2 | Mathlib.Algebra.Group.Center | ∀ {S : Type u_3} [inst : Mul S] (a b : S), Commute a b = (a * b = b * a) | null | false |
DFinsupp.lex_lt_of_lt | Mathlib.Data.DFinsupp.Lex | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Zero (α i)] [inst_1 : (i : ι) → PartialOrder (α i)]
(r : ι → ι → Prop) [IsStrictOrder ι r] {x y : Π₀ (i : ι), α i}, x < y → Pi.Lex r (fun {i} x1 x2 => x1 < x2) ⇑x ⇑y | null | true |
_private.Lean.Elab.DocString.0.Lean.Doc.Ref.seen | Lean.Elab.DocString | {α : Sort u_1} → Lean.Doc.Ref✝ α → Bool | null | true |
Ideal.height_strict_mono_of_isPrime | Mathlib.RingTheory.Ideal.Height | ∀ {R : Type u_1} [inst : CommRing R] {I J : Ideal R} [I.IsPrime], I < J → ∀ [I.FiniteHeight], I.height < J.height | null | true |
List.Sublist.bagInter_inter | Mathlib.Data.List.Lattice | ∀ {α : Type u_1} {l₁ l₂ : List α} [inst : DecidableEq α], (l₁.bagInter l₂).Sublist (l₁ ∩ l₂) | null | true |
LinearMap.toAddMonoidHom_proj | Mathlib.LinearAlgebra.Pi | ∀ {R : Type u} {ι : Type x} [inst : Semiring R] {φ : ι → Type i} [inst_1 : (i : ι) → AddCommMonoid (φ i)]
[inst_2 : (i : ι) → Module R (φ i)] (i : ι), (LinearMap.proj i).toAddMonoidHom = Pi.evalAddMonoidHom φ i | null | true |
Array.findIdx?_isSome | Init.Data.Array.Find | ∀ {α : Type u_1} {xs : Array α} {p : α → Bool}, (Array.findIdx? p xs).isSome = xs.any p | null | true |
Std.TreeMap.instSliceableRoiSlice._auto_1 | Std.Data.TreeMap.Slice | Lean.Syntax | null | false |
Lean.Grind.CommRing.Stepwise.superpose_certC | Init.Grind.Ring.CommSolver | ℤ →
Lean.Grind.CommRing.Mon →
Lean.Grind.CommRing.Poly →
ℤ → Lean.Grind.CommRing.Mon → Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly → ℕ → Bool | null | true |
Std.HashMap.toArray_keysIter | Std.Data.HashMap.IteratorLemmas | ∀ {α β : Type u} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α],
m.keysIter.toArray = m.keysArray | null | true |
Std.Http.URI.EncodedQueryString.ofByteArray? | Std.Http.Data.URI.Encoding | ByteArray →
(r : optParam (UInt8 → Bool) Std.Http.Internal.Char.isQueryChar) → Option (Std.Http.URI.EncodedQueryString r) | Attempts to create an `EncodedQueryString` from a `ByteArray`. Returns `some` if the byte array contains
only valid encoded query characters and all percent signs are followed by exactly two hex digits, `none` otherwise.
| true |
_private.Init.Data.UInt.Lemmas.0.USize.toUInt8_eq._simp_1_1 | Init.Data.UInt.Lemmas | ∀ {a b : UInt8}, (a = b) = (a.toNat = b.toNat) | null | false |
CategoryTheory.Limits.biprod.fst_op_opIso_hom_assoc | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(P Q : C) [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct P Q] {Z : Cᵒᵖ} (h : Opposite.op P ⊞ Opposite.op Q ⟶ Z),
CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.biprod.fst.op
(Category... | null | true |
Finset.tendsto_Ico_neg_atTop_atTop | Mathlib.Order.Filter.AtTopBot.Interval | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α]
[inst_3 : LocallyFiniteOrder α] [NoTopOrder α], Filter.Tendsto (fun a => Finset.Ico (-a) a) Filter.atTop Filter.atTop | null | true |
_private.Mathlib.Analysis.Calculus.TangentCone.ProperSpace.0.tangentConeAt_nonempty_of_properSpace._simp_1_7 | Mathlib.Analysis.Calculus.TangentCone.ProperSpace | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : LE α] [ZeroLEOneClass α], (0 ≤ 1) = True | null | false |
Aesop.Options.ctorIdx | Aesop.Options.Public | Aesop.Options → ℕ | null | false |
_private.Lean.Elab.Match.0.Lean.Elab.Term.isPatternVar._sparseCasesOn_4 | Lean.Elab.Match | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
(Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.WithTerminal.down | Mathlib.CategoryTheory.WithTerminal.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} → (CategoryTheory.WithTerminal.of X ⟶ CategoryTheory.WithTerminal.of Y) → (X ⟶ Y) | Helper function for typechecking. | true |
Matrix.toBlocks₂₁ | Mathlib.Data.Matrix.Block | {l : Type u_1} →
{m : Type u_2} → {n : Type u_3} → {o : Type u_4} → {α : Type u_12} → Matrix (n ⊕ o) (l ⊕ m) α → Matrix o l α | Given a matrix whose row and column indexes are sum types, we can extract the corresponding
"bottom left" submatrix. | true |
HomotopicalAlgebra.RelativeCellComplex.transfiniteCompositionOfShape'._proof_3 | Mathlib.AlgebraicTopology.RelativeCellComplex.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : Type u_4} [inst_1 : LinearOrder J]
[inst_2 : OrderBot J] [inst_3 : SuccOrder J] [inst_4 : WellFoundedLT J] {α : J → Type u_5} {A B : (j : J) → α j → C}
{basicCell : (j : J) → (i : α j) → A j i ⟶ B j i} {X Y : C} {f : X ⟶ Y}
(c : HomotopicalAlgebr... | null | false |
Lean.Meta.Grind.EMatchTheorem.numParams | Lean.Meta.Tactic.Grind.Extension | Lean.Meta.Grind.EMatchTheorem → ℕ | null | true |
CategoryTheory.Abelian.SpectralObject.kernelSequenceE_X₁ | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) (f₂₃ : j ⟶ l)
(h₂₃ : CategoryTheory.CategoryStruct.... | null | true |
Dioph.«termD&_» | Mathlib.NumberTheory.Dioph | Lean.ParserDescr | Projection preserves Diophantine functions. | true |
partialOrderOfSO._proof_4 | Mathlib.Order.RelClasses | ∀ {α : Type u_1} (r : α → α → Prop) [IsStrictOrder α r] (x y : α), x = y ∨ r x y → y = x ∨ r y x → x = y | null | false |
Std.HashMap.Raw.getKey!_congr | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α] [inst_4 : Inhabited α], m.WF → ∀ {k k' : α}, (k == k') = true → m.getKey! k = m.getKey! k' | null | true |
QuaternionGroup.ctorElimType | Mathlib.GroupTheory.SpecificGroups.Quaternion | {n : ℕ} → {motive : QuaternionGroup n → Sort u} → ℕ → Sort (max 1 u) | null | false |
FourierTransformInv.casesOn | Mathlib.Analysis.Fourier.Notation | {E : Type u} →
{F : Type v} →
{motive : FourierTransformInv E F → Sort u_1} →
(t : FourierTransformInv E F) → ((fourierInv : E → F) → motive { fourierInv := fourierInv }) → motive t | null | false |
FirstOrder.Language.Sentence.realize_cardGe._simp_1 | Mathlib.ModelTheory.Semantics | ∀ (L : FirstOrder.Language) {M : Type w} [inst : L.Structure M] (n : ℕ),
M ⊨ FirstOrder.Language.Sentence.cardGe L n = (↑n ≤ Cardinal.mk M) | null | false |
List.iterate.match_1 | Mathlib.Data.List.Defs | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x | null | false |
_private.Mathlib.Algebra.Order.Ring.Abs.0.geomSum.match_1.eq_2 | Mathlib.Algebra.Order.Ring.Abs | ∀ (motive : ℕ → Sort u_1) (n : ℕ) (h_1 : Unit → motive 0) (h_2 : (n : ℕ) → motive n.succ),
(match n.succ with
| 0 => h_1 ()
| n.succ => h_2 n) =
h_2 n | null | true |
Aesop.RappId.noConfusion | Aesop.Tree.Data | {P : Sort u} → {t t' : Aesop.RappId} → t = t' → Aesop.RappId.noConfusionType P t t' | null | false |
isOpen_compl_iff._simp_1 | Mathlib.Topology.Basic | ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], IsOpen sᶜ = IsClosed s | null | false |
Std.TreeSet.Raw.min?_eq_some_iff_get?_eq_self_and_forall | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → ∀ {km : α}, t.min? = some km ↔ t.get? km = some km ∧ ∀ k ∈ t, (cmp km k).isLE = true | null | true |
_private.Mathlib.Analysis.Convex.Side.0.AffineSubspace.sSameSide_self_iff.match_1_1 | Mathlib.Analysis.Convex.Side | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_3} [inst : CommRing R] [inst_1 : PartialOrder R]
[inst_2 : IsStrictOrderedRing R] [inst_3 : AddCommGroup V] [inst_4 : Module R V] [inst_5 : AddTorsor V P]
{s : AffineSubspace R P} {x : P} (motive : s.SSameSide x x → Prop) (x_1 : s.SSameSide x x),
(∀ (h : s.WSameSide x x... | null | false |
SimpleGraph.isNClique_iff | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} (G : SimpleGraph α) {n : ℕ} {s : Finset α}, G.IsNClique n s ↔ G.IsClique ↑s ∧ s.card = n | null | true |
Pi.normedCommGroup._proof_1 | Mathlib.Analysis.Normed.Group.Constructions | ∀ {ι : Type u_1} {G : ι → Type u_2} [inst : (i : ι) → NormedCommGroup (G i)] (a b : (i : ι) → G i), a * b = b * a | null | false |
kroneckerTMulLinearEquiv._proof_2 | Mathlib.RingTheory.MatrixAlgebra | ∀ (l : Type u_1) (m : Type u_3) (n : Type u_4) (p : Type u_5) (R : Type u_8) (S : Type u_7) (M : Type u_6)
(N : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid N]
[inst_4 : Algebra R S] [inst_5 : Module R M] [inst_6 : Module S M] [inst_7 : Module R N]
[in... | null | false |
Function.Injective.invOfMemRange_surjective | Mathlib.Data.Fintype.Inv | ∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] [inst_1 : DecidableEq β] {f : α → β} (hf : Function.Injective f),
Function.Surjective hf.invOfMemRange | null | true |
BitVec.toFin_mul | Init.Data.BitVec.Lemmas | ∀ {n : ℕ} (x y : BitVec n), (x * y).toFin = x.toFin * y.toFin | null | true |
CategoryTheory.Functor.CommShift.OfComp.iso | Mathlib.CategoryTheory.Shift.CommShift | {C : Type u_1} →
{D : Type u_2} →
{E : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} E] →
{F : CategoryTheory.Functor C D} →
{G : CategoryTheory.Functor D ... | Auxiliary definition for `Functor.CommShift.ofComp`. | true |
SSet.const_app | Mathlib.AlgebraicTopology.SimplicialSet.Basic | ∀ {X Y : SSet} (y : Y.obj (Opposite.op { len := 0 })) (n : SimplexCategoryᵒᵖ),
(SSet.const y).app n =
TypeCat.ofHom fun x => (CategoryTheory.ConcreteCategory.hom (Y.map ((Opposite.unop n).const { len := 0 } 0).op)) y | null | true |
AlgHom.fieldRange._proof_1 | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {K : Type u_3} {L : Type u_1} {L' : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Field L']
[inst_3 : Algebra K L] [inst_4 : Algebra K L'], RingHomClass (L →ₐ[K] L') L L' | null | false |
_private.Mathlib.Analysis.Calculus.FDeriv.Bilinear.0.IsBoundedBilinearMap.hasStrictFDerivAt._abel_1_4 | Mathlib.Analysis.Calculus.FDeriv.Bilinear | ∀ {E : Type u_2} {F : Type u_3} {G : Type u_1} [inst : NormedAddCommGroup G] {b : E × F → G} (x₁ : E) (y₁ : F) (x₂ : E)
(y₂ : F) (x : E) (y : F),
b (x, y) + b (x₁, y) + (b (x, y₁) + b (x₁, y₁)) - (b (x, y) + b (x₂, y) + (b (x, y₂) + b (x₂, y₂))) -
(b (x, y) + b (x, y₁) + (b (x, y) + b (x₁, y)) - (b (x, y) + b... | null | false |
CategoryTheory.AddMod.comap_obj_X | Mathlib.CategoryTheory.Monoidal.Mod | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D]
{A B : C} [inst_4 : CategoryTheory.AddMonObj A] [inst_5 : CategoryTheory.AddMonObj B]... | null | true |
Graph.IsSubgraph.isNonloopAt_congr | Mathlib.Combinatorics.Graph.Subgraph | ∀ {α : Type u_1} {β : Type u_2} {x : α} {e : β} {G H : Graph α β},
H ≤ G → e ∈ H.edgeSet → (H.IsNonloopAt e x ↔ G.IsNonloopAt e x) | null | true |
Std.Http.Method.proppatch | Std.Http.Data.Method | Std.Http.Method | Set or remove properties on a resource (WebDAV).
Source: https://www.rfc-editor.org/rfc/rfc4918#section-9.2
| true |
Polynomial.card_support_eraseLead_add_one | Mathlib.Algebra.Polynomial.EraseLead | ∀ {R : Type u_1} [inst : Semiring R] {f : Polynomial R}, f ≠ 0 → f.eraseLead.support.card + 1 = f.support.card | null | true |
Std.PRange.UpwardEnumerable.succMany_succ | Init.Data.Range.Polymorphic.UpwardEnumerable | ∀ {n : ℕ} {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : Std.PRange.LawfulUpwardEnumerable α]
[inst_2 : Std.PRange.InfinitelyUpwardEnumerable α] {a : α},
Std.PRange.succMany (n + 1) a = Std.PRange.succ (Std.PRange.succMany n a) | null | true |
AlgebraicGeometry.locallyQuasiFinite_iff_isDiscrete_preimage_singleton | Mathlib.AlgebraicGeometry.Morphisms.QuasiFinite | ∀ {X Y : AlgebraicGeometry.Scheme} {f : X ⟶ Y} [AlgebraicGeometry.LocallyOfFiniteType f],
AlgebraicGeometry.LocallyQuasiFinite f ↔ ∀ (x : ↥Y), IsDiscrete (⇑f ⁻¹' {x}) | null | true |
Algebra.SubmersivePresentation.ofSubsingleton._proof_2 | Mathlib.RingTheory.Extension.Presentation.Submersive | ∀ (R : Type u_1) (S : Type u_3) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[inst_3 : Subsingleton S],
Ideal.span (Set.range fun x => 1) = { val := fun x => 1, σ' := fun x => 1, aeval_val_σ' := ⋯, algebraMap_eq := ⋯ }.ker | null | false |
ENNReal.image_coe_Ioi | Mathlib.Data.ENNReal.Operations | ∀ (x : NNReal), ENNReal.ofNNReal '' Set.Ioi x = Set.Ioo ↑x ⊤ | null | true |
Std.CloseableChannel.instDecidableEqError._proof_2 | Std.Sync.Channel | ∀ (x y : Std.CloseableChannel.Error), ¬x.ctorIdx = y.ctorIdx → x = y → False | null | false |
_private.Lean.Elab.DeclModifiers.0.Lean.Elab.Modifiers.isMeta._sparseCasesOn_1 | Lean.Elab.DeclModifiers | {motive : Lean.Elab.ComputeKind → Sort u} →
(t : Lean.Elab.ComputeKind) → motive Lean.Elab.ComputeKind.meta → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.MethodsRefPointed | Lean.Meta.Tactic.Grind.Types | NonemptyType | null | true |
CompleteDistribLattice.MinimalAxioms.mk.sizeOf_spec | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u} [inst : SizeOf α] (toCompleteLattice : CompleteLattice α)
(inf_sSup_le_iSup_inf : ∀ (a : α) (s : Set α), a ⊓ sSup s ≤ ⨆ b ∈ s, a ⊓ b)
(iInf_sup_le_sup_sInf : ∀ (a : α) (s : Set α), ⨅ b ∈ s, a ⊔ b ≤ a ⊔ sInf s),
sizeOf
{ toCompleteLattice := toCompleteLattice, inf_sSup_le_iSup_inf := inf_sSup_... | null | true |
ProfiniteAddGrp.instPreservesLimitsProfiniteForget₂ContinuousAddMonoidHomCarrierToTopTotallyDisconnectedSpaceToProfiniteContinuousMap | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget₂ ProfiniteAddGrp.{u_1} Profinite) | null | true |
ClosedSubmodule.mk.noConfusion | Mathlib.Topology.Algebra.Module.ClosedSubmodule | {R : Type u_2} →
{M : Type u_3} →
{inst : Semiring R} →
{inst_1 : AddCommMonoid M} →
{inst_2 : TopologicalSpace M} →
{inst_3 : Module R M} →
{P : Sort u} →
{toSubmodule : Submodule R M} →
{isClosed' : IsClosed toSubmodule.carrier} →
... | null | false |
Mathlib.Tactic.AtomM.Recurse.Config.contextual._default | Mathlib.Util.AtomM.Recurse | Bool | null | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.getEntry?.match_1.eq_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u_2} {β : α → Type u_1} (motive : List ((a : α) × β a) → Sort u_3) (k : α) (v : β k)
(l : List ((a : α) × β a)) (h_1 : Unit → motive [])
(h_2 : (k : α) → (v : β k) → (l : List ((a : α) × β a)) → motive (⟨k, v⟩ :: l)),
(match ⟨k, v⟩ :: l with
| [] => h_1 ()
| ⟨k, v⟩ :: l => h_2 k v l) =
h_2... | null | true |
EuclideanGeometry.oangle_sub_right | Mathlib.Geometry.Euclidean.Angle.Oriented.Affine | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] [hd2 : Fact (Module.finrank ℝ V = 2)] [inst_4 : Module.Oriented ℝ V (Fin 2)]
{p p₁ p₂ p₃ : P},
p₁ ≠ p →
p₂ ≠ p →
p₃ ≠ p → EuclideanGeometry.oangle p₁ p p... | Given three points not equal to `p`, the angle between the first and the third at `p` minus
the angle between the second and the third equals the angle between the first and the second. | true |
Mathlib.Linter.linter.style.commandStart | Mathlib.Tactic.Linter.Whitespace | Lean.Option Bool | Deprecated in favour of `linter.style.whitespace` | true |
separableClosure.adjoin_eq_of_isAlgebraic | Mathlib.FieldTheory.PurelyInseparable.Basic | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] (K : Type w) [inst_3 : Field K]
[inst_4 : Algebra F K] [inst_5 : Algebra E K] [IsScalarTower F E K] [Algebra.IsAlgebraic F E],
IntermediateField.adjoin E ↑(separableClosure F K) = separableClosure E K | If `K / E / F` is a field extension tower, such that `E / F` is algebraic, then
`E` adjoin `separableClosure F K` is equal to `separableClosure E K`. | true |
_private.Mathlib.MeasureTheory.VectorMeasure.Integral.0.MeasureTheory.VectorMeasure.integral_neg_cbm._simp_1_2 | Mathlib.MeasureTheory.VectorMeasure.Integral | ∀ {α : 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 α}
{T : Set α → E →L[ℝ] F} {C : ℝ} (hT : MeasureTheory.DominatedFinMeasAdditive μ T C) (f : α → E),
... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.