name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Denumerable.raise'._unsafe_rec | Mathlib.Logic.Equiv.Finset | List ℕ → ℕ → List ℕ | null | false |
Int16.ofBitVec_ofNat | Init.Data.SInt.Lemmas | ∀ (n : ℕ), Int16.ofBitVec (BitVec.ofNat 16 n) = Int16.ofNat n | null | true |
CategoryTheory.Limits.IsLimit.pullbackConeEquivBinaryFanFunctor | Mathlib.CategoryTheory.Limits.Constructions.Over.Products | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y Z : C} →
{f : Y ⟶ X} →
{g : Z ⟶ X} →
{c : CategoryTheory.Limits.PullbackCone f g} →
CategoryTheory.Limits.IsLimit c →
CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.pullbackConeEquivBinaryFan.fu... | A binary fan in `Over X` is a limit if its corresponding pullback cone to `X` is a limit. | true |
_private.Mathlib.NumberTheory.LSeries.AbstractFuncEq.0.IsStrongFEPair.Λ_eq._proof_1_4 | Mathlib.NumberTheory.LSeries.AbstractFuncEq | ∀ (t : ℝ), 0 < t → t < 1 → t ∈ Set.Ioo 0 1 | null | false |
CategoryTheory.Abelian.Preradical.toColon_hom_left_colonπ | Mathlib.CategoryTheory.Abelian.Preradical.Colon | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(Φ Ψ : CategoryTheory.Abelian.Preradical C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Over.Hom.left (Φ.toColon Ψ).hom) (Φ.colonπ Ψ) = 0 | null | true |
_private.Mathlib.RingTheory.Invariant.Basic.0.Ideal.Quotient.exists_algHom_fixedPoint_quotient_under._simp_1_2 | Mathlib.RingTheory.Invariant.Basic | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
CategoryTheory.ComposableArrows.isoMkSucc_inv | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {n : ℕ} {F G : CategoryTheory.ComposableArrows C (n + 1)}
(α : F.obj' 0 ⋯ ≅ G.obj' 0 ⋯) (β : F.δ₀ ≅ G.δ₀)
(w :
CategoryTheory.CategoryStruct.comp (F.map' 0 1 CategoryTheory.ComposableArrows.homMk₁._proof_4 ⋯)
(CategoryTheory.ComposableArrows... | null | true |
TensorProduct.inner_def | Mathlib.Analysis.InnerProductSpace.TensorProduct | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : InnerProductSpace 𝕜 F]
(x y : TensorProduct 𝕜 E F),
inner 𝕜 x y =
(((TensorProduct.lift (TensorProduct.mapBilinear (RingHom.id 𝕜) E... | null | true |
comap_abs_nhds_zero | Mathlib.Topology.Algebra.Order.Group | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : AddCommGroup G] [inst_2 : LinearOrder G] [IsOrderedAddMonoid G]
[OrderTopology G], Filter.comap abs (nhds 0) = nhds 0 | null | true |
Matrix.transpose_zero | Mathlib.LinearAlgebra.Matrix.Defs | ∀ {m : Type u_2} {n : Type u_3} {α : Type v} [inst : Zero α], Matrix.transpose 0 = 0 | null | true |
RootPairing.Equiv.toEndUnit._proof_9 | Mathlib.LinearAlgebra.RootSystem.Hom | ∀ {ι : Type u_1} {R : Type u_4} {M : Type u_2} {N : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N) (f g : P.Aut),
{ val := ↑(f * g), inv := ↑(RootPairing.Equiv.symm P P (f * g)), val_inv := ⋯, inv_val := ⋯ } =
... | null | false |
SimpleGraph.IsMaximumClique.maximum | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_3} [inst : Finite α] {G : SimpleGraph α} {s : Finset α},
G.IsMaximumClique s → ∀ (t : Finset α), G.IsClique ↑t → t.card ≤ s.card | null | true |
Stream'.Seq.terminates_ofList | Mathlib.Data.Seq.Basic | ∀ {α : Type u} (l : List α), (↑l).Terminates | null | true |
Std.Http.Headers.insertMany | Std.Http.Data.Headers | Std.Http.Headers → Std.Http.Header.Name → Array Std.Http.Header.Value → Std.Http.Headers | Inserts a new key with an array of values.
| true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_683 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
Std.TreeMap.instSliceableRooSlice._auto_1 | Std.Data.TreeMap.Slice | Lean.Syntax | null | false |
_private.Init.Data.Array.Lemmas.0.Array.foldlM_loop_empty._proof_1_2 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {s j : ℕ}, j < s → s = 0 → False | null | false |
_private.Mathlib.Analysis.Calculus.Deriv.Inverse.0.HasDerivWithinAt.eventually_ne._simp_1_2 | Mathlib.Analysis.Calculus.Deriv.Inverse | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
Lean.matchConstNonRecStructure | Lean.MonadEnv | {m : Type → Type} →
{α : Type} →
[Monad m] →
[Lean.MonadEnv m] →
[Lean.MonadError m] →
Lean.Expr → (Unit → m α) → (Lean.InductiveVal → List Lean.Level → Lean.ConstructorVal → m α) → m α | Matches if `e` is a constant that is a non-recursive inductive type with no indices and with one constructor.
Such a type satisfies `Lean.isNonRecStructure`.
See also `Lean.matchConstStructure` for a less restrictive version.
| true |
_private.Init.Data.Nat.Lemmas.0.Nat.decidableExistsLTTR.match_1 | Init.Data.Nat.Lemmas | ∀ {p : ℕ → Prop} [inst : DecidablePred p] (n : ℕ) (motive : (∃ i, ∃ (_ : i < n), decide (p i) = true) → Prop)
(x : ∃ i, ∃ (_ : i < n), decide (p i) = true), (∀ (i : ℕ) (h : i < n) (hf : decide (p i) = true), motive ⋯) → motive x | null | false |
emultiplicity_map_eq | Mathlib.RingTheory.Multiplicity | ∀ {α : Type u_1} {β : Type u_2} [inst : Monoid α] [inst_1 : Monoid β] {F : Type u_3} [inst_2 : EquivLike F α β]
[MulEquivClass F α β] (f : F) {a b : α}, emultiplicity (f a) (f b) = emultiplicity a b | null | true |
_private.Lean.Util.Recognizers.0.Lean.Expr.notNot?.match_1 | Lean.Util.Recognizers | (motive : Option Lean.Expr → Sort u_1) →
(x : Option Lean.Expr) → ((p : Lean.Expr) → motive (some p)) → (Unit → motive none) → motive x | null | false |
_private.Mathlib.Analysis.InnerProductSpace.Spectrum.0.LinearMap.IsSymmetric.unsortedEigenvectorBasis | Mathlib.Analysis.InnerProductSpace.Spectrum | {𝕜 : Type u_1} →
[inst : RCLike 𝕜] →
{E : Type u_2} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : InnerProductSpace 𝕜 E] →
{T : E →ₗ[𝕜] E} →
[FiniteDimensional 𝕜 E] → {n : ℕ} → T.IsSymmetric → Module.finrank 𝕜 E = n → OrthonormalBasis (Fin n) 𝕜 E | null | true |
AdicCompletion.map._proof_5 | Mathlib.RingTheory.AdicCompletion.Functoriality | ∀ {R : Type u_1} [inst : CommRing R], IsScalarTower R R R | null | false |
CFC.abs_ofNat | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Abs | ∀ {A : Type u_2} [inst : Ring A] [inst_1 : StarRing A] [inst_2 : TopologicalSpace A] [inst_3 : Algebra ℝ A]
[inst_4 : ContinuousFunctionalCalculus ℝ A IsSelfAdjoint] [inst_5 : PartialOrder A] [inst_6 : StarOrderedRing A]
[inst_7 : NonnegSpectrumClass ℝ A] [IsTopologicalRing A] [T2Space A] [StarModule ℝ A] (n : ℕ)
... | null | true |
Fin.preimage_val_uIoo_val | Mathlib.Order.Interval.Set.Fin | ∀ {n : ℕ} (i j : Fin n), Fin.val ⁻¹' Set.uIoo ↑i ↑j = Set.uIoo i j | null | true |
_private.Mathlib.CategoryTheory.WithTerminal.Cone.0.CategoryTheory.WithTerminal.coneBack_obj_pt | 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)),
(CategoryTheory.WithTerminal.coneBack✝.obj t).pt =... | null | true |
Units.cfcRpow._auto_1 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | Lean.Syntax | null | false |
CategoryTheory.LaxFunctor._sizeOf_inst | Mathlib.CategoryTheory.Bicategory.Functor.Lax | (B : Type u₁) →
{inst : CategoryTheory.Bicategory B} →
(C : Type u₂) →
{inst_1 : CategoryTheory.Bicategory C} → [SizeOf B] → [SizeOf C] → SizeOf (CategoryTheory.LaxFunctor B C) | null | false |
AddSubgroup.toIntSubmodule._proof_4 | Mathlib.Algebra.Module.Submodule.Lattice | ∀ {M : Type u_1} [inst : AddCommGroup M] {a b : AddSubgroup M},
{ toFun := fun S => { toAddSubmonoid := S.toAddSubmonoid, smul_mem' := ⋯ }, invFun := Submodule.toAddSubgroup,
left_inv := ⋯, right_inv := ⋯ }
a ≤
{ toFun := fun S => { toAddSubmonoid := S.toAddSubmonoid, smul_mem' := ⋯ }, invFun ... | null | false |
FirstOrder.Language.BoundedFormula.mapTermRel.eq_def | Mathlib.ModelTheory.Syntax | ∀ {L : FirstOrder.Language} {L' : FirstOrder.Language} {α : Type u'} {β : Type v'} {g : ℕ → ℕ}
(ft : (n : ℕ) → L.Term (α ⊕ Fin n) → L'.Term (β ⊕ Fin (g n))) (fr : (n : ℕ) → L.Relations n → L'.Relations n)
(h : (n : ℕ) → L'.BoundedFormula β (g (n + 1)) → L'.BoundedFormula β (g n + 1)) (x : ℕ) (x_1 : L.BoundedFormula... | null | true |
Mathlib.Tactic.Translate.TranslateData.unfoldBoundaries? | Mathlib.Tactic.Translate.Expr | Mathlib.Tactic.Translate.TranslateData → Option Mathlib.Tactic.UnfoldBoundary.UnfoldBoundaryExt | The `insert_cast`/`insert_cast_fun` attributes create an abstraction boundary for the tagged
constant when translating it. For example, `Set.Icc`, `Monotone`, `DecidableLT`, `WCovBy` are all
morally self-dual, but their definition is not self-dual. So, in order to allow these constants
to be self-dual, we need to not u... | true |
normalizedGCDMonoidOfLCM._proof_5 | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : NormalizationMonoid α] [inst_2 : DecidableEq α]
(lcm : α → α → α) (lcm_dvd : ∀ {a b c : α}, c ∣ a → b ∣ a → lcm c b ∣ a) (a b : α),
normalize (normalize (if a = 0 then b else if b = 0 then a else Classical.choose ⋯)) =
normalize (if a = 0 then b else if b... | null | false |
Std.ExtHashSet.contains_iff_mem._simp_1 | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashSet α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
{a : α}, (m.contains a = true) = (a ∈ m) | null | false |
Array.le_min?_iff | Init.Data.Array.MinMax | ∀ {α : Type u_1} {a : α} [inst : Min α] [inst_1 : LE α] [Std.LawfulOrderInf α] {xs : Array α},
xs.min? = some a → ∀ {x : α}, x ≤ a ↔ ∀ b ∈ xs, x ≤ b | null | true |
Lean.pp.rawOnError | Lean.Util.PPExt | Lean.Option Bool | null | true |
QuotientGroup.quotientInfEquivProdNormalQuotient.eq_1 | Mathlib.GroupTheory.QuotientGroup.Basic | ∀ {G : Type u} [inst : Group G] (H N : Subgroup G) [hN : N.Normal],
QuotientGroup.quotientInfEquivProdNormalQuotient H N = QuotientGroup.quotientInfEquivProdNormalizerQuotient H N ⋯ | null | true |
_private.Mathlib.Data.EReal.Operations.0.ENNReal.toEReal_sub._simp_1_1 | Mathlib.Data.EReal.Operations | ∀ {r p : NNReal}, ↑r - ↑p = ↑(r - p) | null | false |
CategoryTheory.Functor.mapHomologicalComplexUpToQuasiIsoFactorsh_hom_app_assoc | Mathlib.Algebra.Homology.Localization | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (F : CategoryTheory.Functor C D) {ι : Type u_3} {c : ComplexShape ι}
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Preadditive D]
[inst_4 : CategoryTheory.CategoryWithHo... | null | true |
SemiNormedGrp₁.coe_of | Mathlib.Analysis.Normed.Group.SemiNormedGrp | ∀ (V : Type u) [inst : SeminormedAddCommGroup V], (↧V).carrier = V | null | true |
AdicCompletion.ofLinearEquiv.eq_1 | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) (M : Type u_4) [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : IsAdicComplete I M], AdicCompletion.ofLinearEquiv I M = LinearEquiv.ofBijective (AdicCompletion.of I M) ⋯ | null | true |
Algebra.SubmersivePresentation.isStandardSmoothOfRelativeDimension | Mathlib.RingTheory.Smooth.StandardSmooth | ∀ {n : ℕ} {R : Type u} {S : Type v} {ι : Type w} {σ : Type t} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : Finite σ] [Finite ι] (P : Algebra.SubmersivePresentation R S ι σ),
P.dimension = n → Algebra.IsStandardSmoothOfRelativeDimension n R S | null | true |
ContinuousMap.toNNReal_algebraMap | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unique | ∀ {X : Type u_1} [inst : TopologicalSpace X] (r : NNReal),
((algebraMap ℝ C(X, ℝ)) ↑r).toNNReal = (algebraMap NNReal C(X, NNReal)) r | null | true |
_private.Mathlib.Algebra.Polynomial.Degree.TrailingDegree.0.Polynomial.natTrailingDegree_intCast._simp_1_1 | Mathlib.Algebra.Polynomial.Degree.TrailingDegree | ∀ {R : Type u} [inst : Ring R] (n : ℤ), ↑n = Polynomial.C ↑n | null | false |
MeasureTheory.measure_eq_top_of_setLIntegral_ne_top | Mathlib.MeasureTheory.Integral.Lebesgue.Markov | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ENNReal} {s : Set α},
AEMeasurable f (μ.restrict s) → ∫⁻ (x : α) in s, f x ∂μ ≠ ⊤ → μ {x | x ∈ s ∧ f x = ⊤} = 0 | null | true |
CategoryTheory.CommGrp.forget | Mathlib.CategoryTheory.Monoidal.CommGrp_ | (C : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] → CategoryTheory.Functor (CategoryTheory.CommGrp C) C | The forgetful functor from commutative group objects to the ambient category. | true |
RootPairing.zero_notMem_range_root | Mathlib.LinearAlgebra.RootSystem.Defs | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N) [NeZero 2],
0 ∉ Set.range ⇑P.root | null | true |
Mathlib.Tactic.ITauto.Proof.andIntro.inj | Mathlib.Tactic.ITauto | ∀ {ak : Mathlib.Tactic.ITauto.AndKind} {p₁ p₂ : Mathlib.Tactic.ITauto.Proof} {ak_1 : Mathlib.Tactic.ITauto.AndKind}
{p₁_1 p₂_1 : Mathlib.Tactic.ITauto.Proof},
Mathlib.Tactic.ITauto.Proof.andIntro ak p₁ p₂ = Mathlib.Tactic.ITauto.Proof.andIntro ak_1 p₁_1 p₂_1 →
ak = ak_1 ∧ p₁ = p₁_1 ∧ p₂ = p₂_1 | null | true |
ZeroHom.casesOn | Mathlib.Algebra.Group.Hom.Defs | {M : Type u_10} →
{N : Type u_11} →
[inst : Zero M] →
[inst_1 : Zero N] →
{motive : ZeroHom M N → Sort u} →
(t : ZeroHom M N) →
((toFun : M → N) → (map_zero' : toFun 0 = 0) → motive { toFun := toFun, map_zero' := map_zero' }) → motive t | null | false |
FractionalIdeal.isFractional_span_iff | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
{s : Set P}, IsFractional S (Submodule.span R s) ↔ ∃ a ∈ S, ∀ b ∈ s, IsLocalization.IsInteger R (a • b) | null | true |
CategoryTheory.Limits.FormalCoproduct.ι_comp_coproductIsoCofanPt | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {𝒜 : Type w} {f : 𝒜 → CategoryTheory.Limits.FormalCoproduct C}
(i : 𝒜),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Sigma.ι f i)
(CategoryTheory.Limits.FormalCoproduct.coproductIsoCofanPt 𝒜 f).hom =
(CategoryTheory.Limits.FormalCop... | null | true |
LinearMap.coe_toContinuousLinearMap | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u} [hnorm : NontriviallyNormedField 𝕜] {E : Type v} [inst : AddCommGroup E] [inst_1 : Module 𝕜 E]
[inst_2 : TopologicalSpace E] [inst_3 : IsTopologicalAddGroup E] [inst_4 : ContinuousSMul 𝕜 E] {F' : Type x}
[inst_5 : AddCommGroup F'] [inst_6 : Module 𝕜 F'] [inst_7 : TopologicalSpace F'] [inst_8 : I... | null | true |
ENNReal.add_ne_top | Mathlib.Basic.ENNReal.Operations | ∀ {a b : ENNReal}, a + b ≠ ⊤ ↔ a ≠ ⊤ ∧ b ≠ ⊤ | null | true |
Int.emod_zero | Init.Data.Int.DivMod.Bootstrap | ∀ (a : ℤ), a % 0 = a | null | true |
MeasureTheory.tendsto_measure_of_null_frontier | Mathlib.MeasureTheory.Measure.Portmanteau | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] [inst_1 : TopologicalSpace Ω] [OpensMeasurableSpace Ω] {ι : Type u_2}
{L : Filter ι} {μ : MeasureTheory.Measure Ω} {μs : ι → MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure μ]
[∀ (i : ι), MeasureTheory.IsProbabilityMeasure (μs i)],
(∀ (G : Set Ω), IsOpen G ... | One implication of the portmanteau theorem:
For a sequence of Borel probability measures, if the liminf of the measures of any open set is at
least the measure of the open set under a candidate limit measure, then for any set whose
boundary carries no probability mass under the candidate limit measure, then its measure... | true |
RingEquiv.map_sum | Mathlib.Algebra.BigOperators.RingEquiv | ∀ {α : Type u_1} {R : Type u_2} {S : Type u_3} [inst : NonUnitalNonAssocSemiring R]
[inst_1 : NonUnitalNonAssocSemiring S] (g : R ≃+* S) (f : α → R) (s : Finset α), g (∑ x ∈ s, f x) = ∑ x ∈ s, g (f x) | null | true |
Polynomial.Splits.eval_derivative | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : CommRing R] {f : Polynomial R} [inst_1 : IsDomain R] [inst_2 : DecidableEq R],
f.Splits →
∀ (x : R),
Polynomial.eval x (Polynomial.derivative f) =
f.leadingCoeff *
(Multiset.map (fun a => (Multiset.map (fun x_1 => x - x_1) (f.roots.erase a)).prod) f.roots).sum | null | true |
Std.TreeMap.Raw.mem_toList_iff_getElem?_eq_some._simp_1 | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp]
[Std.LawfulEqCmp cmp], t.WF → ∀ {k : α} {v : β}, ((k, v) ∈ t.toList) = (t[k]? = some v) | null | false |
CategoryTheory.Limits.MultispanIndex.SymmStruct.noConfusionType | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{ι : Type w} →
{I : CategoryTheory.Limits.MultispanIndex (CategoryTheory.Limits.MultispanShape.prod ι) C} →
I.SymmStruct →
{C' : Type u} →
[inst' : CategoryTheory.Category.{v, u} C'] →
... | null | false |
CochainComplex.Lifting.cocycle₁._proof_5 | Mathlib.Algebra.Homology.ModelCategory.Lifting | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
{A B X Y : CochainComplex C ℤ} {t : A ⟶ X} {i : A ⟶ B} {p : X ⟶ Y} {b : B ⟶ Y} (sq : CategoryTheory.CommSq t i p b)
(hsq : (n : ℤ) → ⋯.LiftStruct) {Q : CochainComplex C ℤ} {π : B ⟶ Q} {hπ : CategoryTheory.CategoryStru... | null | false |
CategoryTheory.Quiv.comp_eq_comp | Mathlib.CategoryTheory.Category.Quiv | ∀ {X Y Z : CategoryTheory.Quiv} (F : X ⟶ Y) (G : Y ⟶ Z), CategoryTheory.CategoryStruct.comp F G = F ⋙q G | Composition in the category of quivers equals prefunctor composition. | true |
ZMod.ringHom_map_cast | Mathlib.Data.ZMod.Basic | ∀ {n : ℕ} {R : Type u_1} [inst : NonAssocRing R] (f : R →+* ZMod n) (k : ZMod n), f k.cast = k | null | true |
Finsupp.lattice._proof_5 | Mathlib.Order.Preorder.Finsupp | ∀ {ι : Type u_1} {M : Type u_2} [inst : Zero M] [inst_1 : Lattice M] (a b : ι →₀ M), SemilatticeInf.inf a b ≤ b | null | false |
TopRep.ctorIdx | Mathlib.RepresentationTheory.Continuous.TopRep | {k : Type u} → {G : Type v} → {inst : Ring k} → {inst_1 : TopologicalSpace k} → {inst_2 : Monoid G} → TopRep k G → ℕ | null | false |
Lean.Elab.Tactic.iterateExactly'._unsafe_rec | Mathlib.Tactic.Core | {m : Type → Type u} → [Monad m] → ℕ → m Unit → m Unit | null | false |
_private.Mathlib.Analysis.Convex.StrictCombination.0.StrictConvex.centerMass_mem_interior._proof_1_7 | Mathlib.Analysis.Convex.StrictCombination | ∀ {R : Type u_2} {V : Type u_3} {ι : Type u_1} [inst : Field R] {w : ι → R} {z : ι → V} (i : ι) (t : Finset ι)
(i' j' : ι), i' ∈ insert i t → j' ∈ insert i t → z i' ≠ z j' → w i' ≠ 0 → w j' ≠ 0 → ∃ i'' ∈ t, ¬w i'' = 0 | null | false |
Lean.Environment.const2ModIdx | Lean.Environment | Lean.Environment → Std.HashMap Lean.Name Lean.ModuleIdx | Mapping from constant name to module (index) where constant has been declared.
Recall that a Lean file has a header where previously compiled modules can be imported.
Each imported module has a unique `ModuleIdx`.
Many extensions use the `ModuleIdx` to efficiently retrieve information stored in imported modules.
Remar... | true |
Int.floor_eq_self_iff_mem | Mathlib.Algebra.Order.Floor.Ring | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : LinearOrder R] [inst_2 : FloorRing R] (a : R),
↑⌊a⌋ = a ↔ a ∈ Set.range Int.cast | null | true |
Affine.Simplex.disjoint_interior_closedInterior_faceOpposite | Mathlib.LinearAlgebra.AffineSpace.Simplex.Basic | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] [inst_4 : PartialOrder k] {n : ℕ} [inst_5 : NeZero n] (s : Affine.Simplex k P n)
(i : Fin (n + 1)), Disjoint s.interior (s.faceOpposite i).closedInterior | null | true |
_private.Init.Data.Array.Lemmas.0.Array.map_eq_append_iff._simp_1_2 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {xs : Array α} {ys zs : Array β} {f : α → Option β},
(Array.filterMap f xs = ys ++ zs) = ∃ as bs, xs = as ++ bs ∧ Array.filterMap f as = ys ∧ Array.filterMap f bs = zs | null | false |
Algebra.tensorH1CotangentOfIsLocalization._proof_3 | Mathlib.RingTheory.Etale.Kaehler | ∀ (R : Type u_2) {S : Type u_3} (T : Type u_1) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T]
[inst_3 : Algebra R S] [inst_4 : Algebra R T] [inst_5 : Algebra S T] [inst_6 : IsScalarTower R S T] (M : Submonoid S)
[IsLocalization M T] (y : (Algebra.Generators.self R S).toExtension.Ring)
(hy : y ∈ S... | null | false |
AlgebraicGeometry.isLocalizing_pushforward_of_isLocalizing | Mathlib.AlgebraicGeometry.Modules.Tilde | ∀ {R S : CommRingCat} (φ : R ⟶ S) {M : (AlgebraicGeometry.Spec S).Modules},
AlgebraicGeometry.IsLocalizing (AlgebraicGeometry.modulesSpecToSheaf.obj M) →
AlgebraicGeometry.IsLocalizing
(AlgebraicGeometry.modulesSpecToSheaf.obj
((AlgebraicGeometry.Scheme.Modules.pushforward (AlgebraicGeometry.Spec.ma... | null | true |
Polynomial.trailingDegree_le_of_ne_zero | Mathlib.Algebra.Polynomial.Degree.TrailingDegree | ∀ {R : Type u} {n : ℕ} [inst : Semiring R] {p : Polynomial R}, p.coeff n ≠ 0 → p.trailingDegree ≤ ↑n | null | true |
NonUnitalRingHom.copy | Mathlib.Algebra.Ring.Hom.Defs | {α : Type u_2} →
{β : Type u_3} →
[inst : NonUnitalNonAssocSemiring α] →
[inst_1 : NonUnitalNonAssocSemiring β] → (f : α →ₙ+* β) → (f' : α → β) → f' = ⇑f → α →ₙ+* β | Copy of a `RingHom` with a new `toFun` equal to the old one. Useful to fix definitional
equalities. | true |
_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 |
AbstractMeasure.isAddApply | Mathlib.NumberTheory.Padics.Measure.Basic | ∀ {X : Type u_1} {R : Type u_3} {E : Type u_4} [inst : TopologicalSpace X] [inst_1 : AddCommGroup E]
[inst_2 : TopologicalSpace E] [inst_3 : IsTopologicalAddGroup E] [inst_4 : CommRing R] [inst_5 : TopologicalSpace R]
[inst_6 : IsTopologicalRing R] [inst_7 : Module R E], IsAddApply (AbstractMeasure X R E) C(X, R) E | 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_1} [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 |
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 |
UniqueFactorizationMonoid.iff_of_isLocalizationAway_of_prime | Mathlib.RingTheory.Ideal.UFD | ∀ {R : Type u_1} [inst : CommRing R] [IsDomain R] [IsNoetherianRing R] {x : R},
Prime x →
∀ (S : Type u_2) [inst_3 : CommRing S] [inst_4 : Algebra R S] [IsLocalization.Away x S],
UniqueFactorizationMonoid R ↔ UniqueFactorizationMonoid S | null | true |
Lean.Parser.Term.termTry | Lean.Parser.Do | Lean.Parser.Parser | null | 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 |
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 |
intervalIntegral.derivWithin_integral_of_tendsto_ae_left._auto_1 | Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | Lean.Syntax | null | false |
CategoryTheory.Limits.BinaryFan.mk.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.BinaryFan | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y P : C} (π₁ : P ⟶ X) (π₂ : P ⟶ Y),
CategoryTheory.Limits.BinaryFan.mk π₁ π₂ =
{ pt := P,
π :=
{
app := fun x =>
match x with
| { as := j } =>
match j with
| CategoryTheory.Limit... | null | true |
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.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 |
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 |
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 |
CategoryTheory.Functor.PreservesCardinalPresentable.rec | Mathlib.CategoryTheory.Presentable.PreservesCardinalPresentable | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{F : CategoryTheory.Functor C D} →
{κ : Cardinal.{w}} →
[inst_2 : Fact κ.IsRegular] →
{motive : F.PreservesCardinalPresentable κ → S... | null | false |
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 |
Array.findIdx?_isSome | Init.Data.Array.Find | ∀ {α : Type u_1} {xs : Array α} {p : α → Bool}, (Array.findIdx? p xs).isSome = xs.any p | null | true |
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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.