name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
natCast_eq_one | Mathlib.Algebra.Order.Kleene | ∀ {α : Type u_1} [inst : IdemSemiring α] {n : ℕ}, n ≠ 0 → ↑n = 1 | null | true |
CategoryTheory.Limits.hasFiniteLimits_of_hasLimitsLimits_of_createsFiniteLimits | Mathlib.CategoryTheory.Limits.Preserves.Creates.Finite | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) [CategoryTheory.Limits.HasFiniteLimits D]
[CategoryTheory.Limits.CreatesFiniteLimits F], CategoryTheory.Limits.HasFiniteLimits C | null | true |
CategoryTheory.Comma.unopFunctorCompFst | Mathlib.CategoryTheory.Comma.Basic | {A : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
{B : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
{T : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} T] →
(L : CategoryTheory.Functor A T) →
(R : CategoryTheory.Functor B T) →
... | Composing `unopFunctor L R` with `(fst L R).op` is isomorphic to `snd L.op R.op`. | true |
Equiv.Set.powerset._proof_4 | Mathlib.Logic.Equiv.Set | ∀ {α : Type u_1} (S : Set α) (x : ↑(𝒫 S)), (fun x => ⟨Subtype.val '' x, ⋯⟩) ((fun x => Subtype.val ⁻¹' ↑x) x) = x | null | false |
Filter.image_mem_map_iff | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {m : α → β} {s : Set α},
Function.Injective m → (m '' s ∈ Filter.map m f ↔ s ∈ f) | null | true |
Std.Time.Hour.Offset.ofDays | Std.Time.Date.Basic | Std.Time.Day.Offset → Std.Time.Hour.Offset | Convert `Day.Offset` into `Hour.Offset`.
| true |
_private.Init.Data.SInt.Lemmas.0.Int32.toInt64_lt._simp_1_2 | Init.Data.SInt.Lemmas | ∀ {x y : Int64}, (x < y) = (x.toInt < y.toInt) | null | false |
SSet.finite_of_hasDimensionLT | Mathlib.AlgebraicTopology.SimplicialSet.Finite | ∀ (X : SSet) (d : ℕ) [X.HasDimensionLT d], (∀ i < d, Finite ↑(X.nonDegenerate i)) → X.Finite | null | true |
Polynomial.coeff_mul_add_eq_of_natDegree_le | Mathlib.Algebra.Polynomial.Degree.Operations | ∀ {R : Type u} [inst : Semiring R] {df dg : ℕ} {f g : Polynomial R},
f.natDegree ≤ df → g.natDegree ≤ dg → (f * g).coeff (df + dg) = f.coeff df * g.coeff dg | null | true |
Language.one_add_self_mul_kstar_eq_kstar | Mathlib.Computability.Language | ∀ {α : Type u_1} (l : Language α), 1 + l * KStar.kstar l = KStar.kstar l | null | true |
_private.Std.Do.Triple.SpecLemmas.0.Std.Do.Spec.get_EStateM._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 |
Units.Simps.val_inv.eq_1 | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : Monoid α] (u : αˣ), Units.Simps.val_inv u = ↑u⁻¹ | null | true |
Int16.add_eq_left._simp_1 | Init.Data.SInt.Lemmas | ∀ {a b : Int16}, (a + b = a) = (b = 0) | null | false |
Std.ExtDHashMap.getKey_eq_getKey! | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] [inst_2 : Inhabited α] {a : α} {h : a ∈ m}, m.getKey a h = m.getKey! a | null | true |
Int8.toInt16_xor | Init.Data.SInt.Bitwise | ∀ (a b : Int8), (a ^^^ b).toInt16 = a.toInt16 ^^^ b.toInt16 | null | true |
_private.Mathlib.Order.Filter.Map.0.Filter.compl_mem_kernMap._simp_1_1 | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {m : α → β} {f : Filter α} {s : Set β},
(s ∈ Filter.kernMap m f) = ∃ t, tᶜ ∈ f ∧ m '' t = sᶜ | null | false |
divp_mul_eq_mul_divp | Mathlib.Algebra.Group.Units.Basic | ∀ {α : Type u} [inst : CommMonoid α] (x y : α) (u : αˣ), x /ₚ u * y = x * y /ₚ u | null | true |
_private.Init.Data.Array.Erase.0.Array.eraseIdx_set._proof_3 | Init.Data.Array.Erase | ∀ {α : Type u_1} {xs : Array α} {i : ℕ} {a : α} {hi : i < xs.size} {j : ℕ}, j < i → ¬i - 1 < xs.size - 1 → False | null | false |
Std.Do.SPred.Tactic.instIsPure | Std.Do.SPred.DerivedLaws | ∀ {φ : Prop} {σ : Type u_1} {s : σ} (σs : List (Type u_1)) (P : Std.Do.SPred (σ :: σs))
[inst : Std.Do.SPred.Tactic.IsPure P φ], Std.Do.SPred.Tactic.IsPure (P s) φ | null | true |
String.Slice.RevByteIterator.ctorIdx | Init.Data.String.Iterate | String.Slice.RevByteIterator → ℕ | null | false |
NonUnitalSubsemiring.corner._proof_4 | Mathlib.RingTheory.Idempotents | ∀ {R : Type u_1} (e : R) [inst : NonUnitalSemiring R] {a b : R},
a ∈ (Subsemigroup.corner e).carrier → b ∈ (Subsemigroup.corner e).carrier → a * b ∈ (Subsemigroup.corner e).carrier | null | false |
Std.DTreeMap.Internal.Impl.get_insertIfNew! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [inst : Std.TransOrd α]
[inst_1 : Std.LawfulEqOrd α] (h : t.WF) {k a : α} {v : β k} {h₁ : a ∈ Std.DTreeMap.Internal.Impl.insertIfNew! k v t},
(Std.DTreeMap.Internal.Impl.insertIfNew! k v t).get a h₁ =
if h₂ : compare k a = Or... | null | true |
Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.delete_iff | Std.Tactic.BVDecide.LRAT.Internal.Clause | ∀ {n : ℕ} (c : Std.Tactic.BVDecide.LRAT.Internal.DefaultClause n)
(l l' : Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)),
l' ∈ (c.delete l).toList ↔ l' ≠ l ∧ l' ∈ c.toList | null | true |
Nat.add_div | Init.Data.Nat.Div.Lemmas | ∀ {a b c : ℕ}, 0 < c → (a + b) / c = a / c + b / c + if c ≤ a % c + b % c then 1 else 0 | null | true |
CategoryTheory.Limits.binaryFanZeroRightIsLimit._proof_1 | Mathlib.CategoryTheory.Limits.Constructions.ZeroObjects | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C] (X : C)
(s : CategoryTheory.Limits.BinaryFan X 0),
CategoryTheory.CategoryStruct.comp s.fst (CategoryTheory.CategoryStruct.id X) = s.fst | null | false |
_private.Lean.Meta.Tactic.Cbv.BuiltinCbvSimprocs.String.0._regBuiltin._private.Lean.Meta.Tactic.Cbv.BuiltinCbvSimprocs.String.0.Lean.Meta.Tactic.Cbv.simpStringToList.declare_24._@.Lean.Meta.Tactic.Cbv.BuiltinCbvSimprocs.String.1792954707._hygCtx._hyg.13 | Lean.Meta.Tactic.Cbv.BuiltinCbvSimprocs.String | IO Unit | null | false |
AddMonoidAlgebra.toRingHom_mapRingEquiv | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_3} {S : Type u_4} {M : Type u_6} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : AddMonoid M]
(e : R ≃+* S), (AddMonoidAlgebra.mapRingEquiv M e).toRingHom = AddMonoidAlgebra.mapRingHom M ↑e | null | true |
_private.Mathlib.FieldTheory.IsAlgClosed.Basic.0.IsAlgClosed.liftAux | Mathlib.FieldTheory.IsAlgClosed.Basic | (K : Type u) →
[inst : Field K] →
(L : Type v) →
(M : Type w) →
[inst_1 : Field L] →
[inst_2 : Algebra K L] →
[inst_3 : Field M] → [inst_4 : Algebra K M] → [IsAlgClosed M] → [Algebra.IsAlgebraic K L] → L →ₐ[K] M | Less general version of `lift`. | true |
Iff.mpr | Init.Core | ∀ {a b : Prop}, (a ↔ b) → b → a | Modus ponens for if and only if, reversed. If `a ↔ b` and `b`, then `a`. | true |
_private.Mathlib.GroupTheory.Subgroup.Centralizer.0.Subgroup.normalizerMonoidHom_ker._simp_1_6 | Mathlib.GroupTheory.Subgroup.Centralizer | ∀ {G : Type u_3} [inst : Group G] {a b c : G}, (a = b * c⁻¹) = (a * c = b) | null | false |
_private.Mathlib.Data.List.Basic.0.List.erase_getElem._proof_1_25 | Mathlib.Data.List.Basic | ∀ {ι : Type u_1} [inst : BEq ι] (a : ι) (l : List ι) (n : ℕ) (w : ι),
1 ≤ (List.filter (fun x => x == w) ((a :: l).eraseIdx (n + 1))).length →
0 < (List.findIdxs (fun x => x == w) ((a :: l).eraseIdx (n + 1))).length | null | false |
_private.Mathlib.Data.Set.SMulAntidiagonal.0.Set.SMulAntidiagonal.finite_of_finite_fst._proof_1_3 | Mathlib.Data.Set.SMulAntidiagonal | ∀ {G : Type u_1} {P : Type u_2} {s : Set G} [inst : SMul G P] [IsLeftCancelSMul G P] (t : Set P) (p : P),
∀ x ∈ s.smulAntidiagonal t p, ∀ x_2 ∈ s.smulAntidiagonal t p, x.1 = x_2.1 → x = x_2 | null | false |
Matrix.kroneckerMap_zero_left | Mathlib.LinearAlgebra.Matrix.Kronecker | ∀ {α : Type u_3} {β : Type u_5} {γ : Type u_7} {l : Type u_9} {m : Type u_10} {n : Type u_11} {p : Type u_12}
[inst : Zero α] [inst_1 : Zero γ] (f : α → β → γ),
(∀ (b : β), f 0 b = 0) → ∀ (B : Matrix n p β), Matrix.kroneckerMap f 0 B = 0 | null | true |
_private.Lean.Level.0.Lean.Level.isExplicitSubsumedAux | Lean.Level | Array Lean.Level → ℕ → ℕ → Bool | Auxiliary function for `normalize`.
`maxExplicit` is the maximum explicit universe level at `lvls`.
Return true if it finds a level with offset ≥ maxExplicit.
`i` starts at the first non explicit level.
It assumes `lvls` has been sorted using `normLt`.
| true |
_private.Lean.Meta.Basic.0.Lean.Meta.isSyntheticMVar.match_1 | Lean.Meta.Basic | (motive : Lean.MetavarKind → Sort u_1) →
(__do_lift : Lean.MetavarKind) →
(Unit → motive Lean.MetavarKind.synthetic) →
(Unit → motive Lean.MetavarKind.syntheticOpaque) → ((x : Lean.MetavarKind) → motive x) → motive __do_lift | null | false |
CategoryTheory.Pseudofunctor.DescentData.toDescentDataCompPullFunctorIso | Mathlib.CategoryTheory.Sites.Descent.DescentData | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat) →
{ι : Type t} →
{S : C} →
{X : ι → C} →
{f : (i : ι) → X i ⟶ S} →
{S' : C} →
{p : S' ⟶ S} →
... | Given families of morphisms `f : X i ⟶ S` and `f' : X' j ⟶ S'`, suitable
commutative diagrams `w j : p' j ≫ f (α j) = f' j ≫ p`, this is the natural
isomorphism between the descent data relative to `f'` that are obtained either:
* by considering the obvious descent data relative to `f` given by an object `M : F.obj (op... | true |
MeasureTheory.ProbabilityMeasure.continuous_iff_forall_continuousMap_continuous_integral | Mathlib.MeasureTheory.Measure.ProbabilityMeasure | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] [inst_1 : TopologicalSpace Ω] [inst_2 : OpensMeasurableSpace Ω]
{X : Type u_2} [inst_3 : TopologicalSpace X] {μs : X → MeasureTheory.ProbabilityMeasure Ω} [CompactSpace Ω],
Continuous μs ↔ ∀ (f : C(Ω, ℝ)), Continuous fun x => ∫ (ω : Ω), f ω ∂↑(μs x) | The characterization of weak convergence of probability measures by the usual (defining)
condition that the integrals of every continuous bounded function are continuous. | true |
Metric.frontier_thickening_disjoint | Mathlib.Topology.MetricSpace.Thickening | ∀ {α : Type u} [inst : PseudoEMetricSpace α] (A : Set α),
Pairwise (Function.onFun Disjoint fun r => frontier (Metric.thickening r A)) | null | true |
_private.Lean.Meta.Sym.Simp.App.0.Lean.Meta.Sym.Simp.simpUsingCongrThm | Lean.Meta.Sym.Simp.App | Lean.Expr → Lean.Meta.CongrTheorem → Lean.Meta.Sym.Simp.SimpM Lean.Meta.Sym.Simp.Result | Simplifies arguments of a function application using a pre-generated congruence theorem.
This strategy is used for functions that have complex argument dependencies, particularly
those with proof arguments or `Decidable` instances. Unlike `congrFixedPrefix` and
`congrInterlaced`, which construct proofs on-the-fly usin... | true |
AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.ofRestrict | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {X : TopCat} (Y : AlgebraicGeometry.LocallyRingedSpace) {f : X ⟶ ↑Y.toPresheafedSpace}
(hf : Topology.IsOpenEmbedding ⇑(CategoryTheory.ConcreteCategory.hom f)),
AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion (Y.ofRestrict hf) | null | true |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Summable.0.EisensteinSeries.E2_eq_tsum_cexp._simp_1_6 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Summable | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False | null | false |
_private.Mathlib.Tactic.NormNum.NatFactorial.0.Mathlib.Meta.NormNum.evalNatDescFactorial._proof_2 | Mathlib.Tactic.NormNum.NatFactorial | ∀ (x y z : Q(ℕ)), «$x» =Q «$z» + «$y» | null | false |
DividedPowers.coincide_on_smul | Mathlib.RingTheory.DividedPowers.Basic | ∀ {A : Type u_1} [inst : CommSemiring A] {I : Ideal A} {a : A} (hI : DividedPowers I) {J : Ideal A}
(hJ : DividedPowers J) {n : ℕ}, a ∈ I • J → hI.dpow n a = hJ.dpow n a | If J is another ideal of A with divided powers,
then the divided powers of I and J coincide on I • J
[Berthelot-1974], 1.6.1 (ii) | true |
ContRepresentation.coind₁.congr_simp | Mathlib.RepresentationTheory.Continuous.Basic | ∀ {R : Type u_1} {V : Type u_3} [inst : Ring R] [inst_1 : AddCommGroup V] [inst_2 : TopologicalSpace V]
[inst_3 : IsTopologicalAddGroup V] [inst_4 : Module R V] {G : Type u_6} [inst_5 : Group G]
[inst_6 : TopologicalSpace G] [inst_7 : TopologicalSpace R] [inst_8 : ContinuousSMul R V]
[inst_9 : IsTopologicalGroup ... | null | true |
denselyOrdered_multiplicative_iff | Mathlib.GroupTheory.ArchimedeanDensely | ∀ {X : Type u_2} [inst : LT X], DenselyOrdered (Multiplicative X) ↔ DenselyOrdered X | null | true |
Lean.Lsp.SemanticTokenType.method.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | sizeOf Lean.Lsp.SemanticTokenType.method = 1 | null | true |
RatFunc.valuation_isEquiv_adic_of_valuation_X_le_one | Mathlib.NumberTheory.RatFunc.Ostrowski | ∀ {K : Type u_1} {Γ : Type u_2} [inst : Field K] [inst_1 : LinearOrderedCommGroupWithZero Γ]
{v : Valuation (RatFunc K) Γ} [v.IsRankOneDiscrete] [Valuation.IsTrivialOn K v],
v RatFunc.X ≤ 1 → ∃ u, v.IsEquiv (IsDedekindDomain.HeightOneSpectrum.valuation (RatFunc K) u) | null | true |
_private.Qq.Macro.0.Qq.Impl.quoteLCtx.match_1 | Qq.Macro | (motive : MProd (Array Lean.Expr) Lean.LocalContext → Sort u_1) →
(r : MProd (Array Lean.Expr) Lean.LocalContext) →
((assignments : Array Lean.Expr) → (quotedCtx : Lean.LocalContext) → motive ⟨assignments, quotedCtx⟩) → motive r | null | false |
List.filterMapM.loop._sunfold | Init.Data.List.Control | {m : Type u → Type v} → [Monad m] → {α : Type w} → {β : Type u} → (α → m (Option β)) → List α → List β → m (List β) | null | false |
GrpCat.uliftFunctor_preservesLimitsOfSize | Mathlib.Algebra.Category.Grp.Ulift | CategoryTheory.Limits.PreservesLimitsOfSize.{w', w, u, max u v, u + 1, max (u + 1) (v + 1)} GrpCat.uliftFunctor | The universe lift for groups preserves limits of arbitrary size.
| true |
MeasureTheory.regular_inv_iff | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : TopologicalSpace G] [BorelSpace G] {μ : MeasureTheory.Measure G}
[inst_3 : Group G] [IsTopologicalGroup G], μ.inv.Regular ↔ μ.Regular | null | true |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.alter.match_3.eq_3 | Std.Data.DTreeMap.Internal.Operations | ∀ (motive : Ordering → Sort u_1) (h_1 : Ordering.eq = Ordering.lt → motive Ordering.lt)
(h_2 : Ordering.eq = Ordering.gt → motive Ordering.gt) (h_3 : Ordering.eq = Ordering.eq → motive Ordering.eq),
(match h : Ordering.eq with
| Ordering.lt => h_1 h
| Ordering.gt => h_2 h
| Ordering.eq => h_3 h) =
h... | null | true |
List.MergeSort.Internal.splitRevInTwo_fst._proof_1 | Init.Data.List.Sort.Impl | ∀ {α : Type u_1} {n : ℕ} (l : { l // l.length = n }),
(↑(List.MergeSort.Internal.splitInTwo l).1).reverse.length = (n + 1) / 2 | null | false |
ULift.semiring._proof_5 | Mathlib.Algebra.Ring.ULift | ∀ {R : Type u_2} [inst : Semiring R] (n : ℕ) (x : ULift.{u_1, u_2} R), Monoid.npow (n + 1) x = Monoid.npow n x * x | null | false |
_private.Mathlib.FieldTheory.Extension.0.IntermediateField.nonempty_algHom_adjoin_of_splits.match_1_1 | Mathlib.FieldTheory.Extension | ∀ {F : Type u_3} {E : Type u_1} {K : Type u_2} [inst : Field F] [inst_1 : Field E] [inst_2 : Field K]
[inst_3 : Algebra F E] [inst_4 : Algebra F K] {S : Set E}
(motive : (∃ φ, φ.comp (IntermediateField.inclusion ⋯) = ⊥.emb) → Prop)
(x : ∃ φ, φ.comp (IntermediateField.inclusion ⋯) = ⊥.emb),
(∀ (φ : ↥(Intermediat... | null | false |
Lean.Meta.Sym.Offset.num.elim | Lean.Meta.Sym.Offset | {motive : Lean.Meta.Sym.Offset → Sort u} →
(t : Lean.Meta.Sym.Offset) → t.ctorIdx = 0 → ((k : ℕ) → motive (Lean.Meta.Sym.Offset.num k)) → motive t | null | false |
CategoryTheory.Subgroupoid.instTop._proof_1 | Mathlib.CategoryTheory.Groupoid.Subgroupoid | ∀ {C : Type u_2} [inst : CategoryTheory.Groupoid C] {c d : C} {p : c ⟶ d},
p ∈ Set.univ → CategoryTheory.Groupoid.inv p ∈ Set.univ | null | false |
CategoryTheory.Limits.CatCospanTransform.inv_whiskerRight | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} {A' : Type u₄} {B' : Type u₅} {C' : Type u₆} {A'' : Type u₇} {B'' : Type u₈}
{C'' : Type u₉} [inst : CategoryTheory.Category.{v₁, u₁} A] [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor A B} {G : Categ... | null | true |
differentiableWithinAt_comp_sub | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : 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}
{x : E} {s : Set E} (a : E),
DifferentiableWithinAt 𝕜 (fun x => f (x - a)) s x ↔ DifferentiableWi... | null | true |
CochainComplex.ConnectData.d_negSucc | Mathlib.Algebra.Homology.Embedding.Connect | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{K : ChainComplex C ℕ} {L : CochainComplex C ℕ} (h : CochainComplex.ConnectData K L) (n m : ℕ),
h.d (Int.negSucc n) (Int.negSucc m) = K.d n m | null | true |
Std.Http.Header.TransferEncoding.noConfusion | Std.Http.Data.Headers.Basic | {P : Sort u} →
{t t' : Std.Http.Header.TransferEncoding} → t = t' → Std.Http.Header.TransferEncoding.noConfusionType P t t' | null | false |
EReal.abs_neg | Mathlib.Data.EReal.Inv | ∀ (x : EReal), (-x).abs = x.abs | null | true |
Std.Http.Internal.Mock.Server.casesOn | Std.Http.Transport | {motive : Std.Http.Internal.Mock.Server → Sort u} →
(t : Std.Http.Internal.Mock.Server) →
((shared : Std.Http.Internal.Mock.SharedState✝) → motive { shared := shared }) → motive t | null | false |
Mathlib.Tactic.Ring.ExProd.cast._unsafe_rec | Mathlib.Tactic.Ring.Basic | {u : Lean.Level} →
{α : Q(Type u)} →
(sα : Q(CommSemiring «$α»)) →
{v : Lean.Level} →
{β : Q(Type v)} →
{sβ : Q(CommSemiring «$β»)} →
{a : Q(«$α»)} → Mathlib.Tactic.Ring.ExProd sα a → (a : Q(«$β»)) × Mathlib.Tactic.Ring.ExProd sβ a | null | false |
Std.DHashMap.Raw.get!_inter_of_mem_right | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Raw α β}
[inst_2 : LawfulBEq α], m₁.WF → m₂.WF → ∀ {k : α} [inst_3 : Inhabited (β k)], k ∈ m₂ → (m₁ ∩ m₂).get! k = m₁.get! k | null | true |
Lean.Meta.Grind.SplitDiagInfo.c | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.SplitDiagInfo → Lean.Expr | null | true |
Lean.Meta.Grind.Arith.Cutsat.ToIntInfo.toIntInst | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToIntInfo | Lean.Meta.Grind.Arith.Cutsat.ToIntInfo → Lean.Expr | null | true |
Matrix.frobenius_norm_replicateRow | Mathlib.Analysis.Matrix.Normed | ∀ {m : Type u_3} {α : Type u_5} {ι : Type u_7} [inst : Fintype m] [inst_1 : Unique ι]
[inst_2 : SeminormedAddCommGroup α] (v : m → α), ‖Matrix.replicateRow ι v‖ = ‖WithLp.toLp 2 v‖ | null | true |
AlgebraicGeometry.Scheme.Pullback.range_diagonal_subset_diagonalCoverDiagonalRange | Mathlib.AlgebraicGeometry.Morphisms.Separated | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (𝒰 : Y.OpenCover)
(𝒱 : (i : 𝒰.I₀) → (CategoryTheory.Limits.pullback f (𝒰.f i)).OpenCover),
Set.range ⇑(CategoryTheory.Limits.pullback.diagonal f) ⊆
↑(AlgebraicGeometry.Scheme.Pullback.diagonalCoverDiagonalRange f 𝒰 𝒱) | null | true |
NonUnitalAlgebra.map_top | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : Module R A] [inst_3 : NonUnitalNonAssocSemiring B] [inst_4 : Module R B] [inst_5 : IsScalarTower R A A]
[inst_6 : SMulCommClass R A A] (f : A →ₙₐ[R] B), NonUnitalSubalgebra.map f ⊤ = NonUnitalAlgHom.ran... | null | true |
Lean.ImportArtifacts.size | Lean.Setup | Lean.ImportArtifacts → ℕ | null | true |
NumberField.mixedEmbedding.convexBodySum.congr_simp | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K] (B B_1 : ℝ),
B = B_1 →
∀ (a a_1 : NumberField.mixedEmbedding.mixedSpace K),
a = a_1 → NumberField.mixedEmbedding.convexBodySum K B a = NumberField.mixedEmbedding.convexBodySum K B_1 a_1 | null | true |
_private.Lean.Server.Requests.0.Lean.Server.chainLspRequestHandler.match_1 | Lean.Server.Requests | (motive : Option Lean.Json → Sort u_1) →
(x : Option Lean.Json) → (Unit → motive none) → ((response : Lean.Json) → motive (some response)) → motive x | null | false |
Lean.Elab.Tactic.MkSimpContextResult | Lean.Elab.Tactic.Simp | Type | null | true |
AntivaryOn.neg_left | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : AddCommGroup α] [inst_1 : Preorder α] [IsOrderedAddMonoid α]
[inst_3 : PartialOrder β] {s : Set ι} {f : ι → α} {g : ι → β}, AntivaryOn f g s → MonovaryOn (-f) g s | null | true |
_private.Lean.Elab.Tactic.Change.0.Lean.Elab.Tactic.evalChange.match_1 | Lean.Elab.Tactic.Change | (motive : Lean.Expr × List Lean.MVarId → Sort u_1) →
(x : Lean.Expr × List Lean.MVarId) →
((hTy' : Lean.Expr) → (mvars : List Lean.MVarId) → motive (hTy', mvars)) → motive x | null | false |
Lean.Linter.LinterOptions._sizeOf_1 | Lean.Linter.Init | Lean.Linter.LinterOptions → ℕ | null | false |
_private.Mathlib.Analysis.Complex.Exponential.0.Real.exp_lt_two_add_div_two_sub._proof_1_4 | Mathlib.Analysis.Complex.Exponential | ∀ {x : ℝ}, x < 2 → x / 2 ≤ 1 | null | false |
AddGroupSeminorm.rec | Mathlib.Analysis.Normed.Group.Seminorm | {G : Type u_6} →
[inst : AddGroup G] →
{motive : AddGroupSeminorm G → Sort u} →
((toFun : G → ℝ) →
(map_zero' : toFun 0 = 0) →
(add_le' : ∀ (r s : G), toFun (r + s) ≤ toFun r + toFun s) →
(neg' : ∀ (r : G), toFun (-r) = toFun r) →
motive { toFun := toFun, ... | null | false |
GrpCat.limitGroup._proof_3 | Mathlib.Algebra.Category.Grp.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J GrpCat)
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget GrpCat)).sections]
(a b c : (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget GrpCat))).pt),
a * b * c = a * (b * c) | null | false |
Ideal.IsHomogeneous.iSup₂ | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Ideal | ∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_3} [inst : Semiring A] [inst_1 : DecidableEq ι] [inst_2 : AddMonoid ι]
[inst_3 : SetLike σ A] [inst_4 : AddSubmonoidClass σ A] {𝒜 : ι → σ} [inst_5 : GradedRing 𝒜] {κ : Sort u_4}
{κ' : κ → Sort u_5} {f : (i : κ) → κ' i → Ideal A},
(∀ (i : κ) (j : κ' i), Ideal.IsHomogen... | null | true |
List.max?.eq_1 | Init.Data.List.MinMax | ∀ {α : Type u} [inst : Max α], [].max? = none | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Basic.0.SimpleGraph.edgeDisjointTriangles_iff_mem_sym2_subsingleton._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Triangle.Basic | ∀ {α : Type u_1} {s : Finset α} {m : Sym2 α}, (m ∈ s.sym2) = ∀ a ∈ m, a ∈ s | null | false |
Matroid.IsBasis.cardinalMk_le_cRk | Mathlib.Combinatorics.Matroid.Rank.Cardinal | ∀ {α : Type u} {M : Matroid α} {I X : Set α}, M.IsBasis I X → Cardinal.mk ↑I ≤ M.cRk X | null | true |
Equiv.Perm.toList_ne_singleton | Mathlib.GroupTheory.Perm.Cycle.Concrete | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] (p : Equiv.Perm α) (x y : α), p.toList x ≠ [y] | null | true |
CategoryTheory.Limits.IsZero.iso._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.ZeroObjects | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} (hX : CategoryTheory.Limits.IsZero X),
CategoryTheory.CategoryStruct.comp (hX.to_ Y) (hX.from_ Y) = CategoryTheory.CategoryStruct.id X | null | false |
Std.Rco.forIn'_eq_forIn'_toArray | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rco α} [inst : LE α] [inst_1 : LT α] [inst_2 : DecidableLT α]
[inst_3 : Std.PRange.UpwardEnumerable α] [inst_4 : Std.PRange.LawfulUpwardEnumerableLE α]
[inst_5 : Std.PRange.LawfulUpwardEnumerableLT α] [inst_6 : Std.Rxo.IsAlwaysFinite α]
[inst_7 : Std.PRange.LawfulUpwardEnumerable α] {γ : T... | null | true |
Turing.PartrecToTM2.Λ'.instDecidableEq._proof_38 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (f : Option Turing.PartrecToTM2.Γ' → Turing.PartrecToTM2.Λ') (p : Turing.PartrecToTM2.Γ' → Bool)
(k₁ k₂ : Turing.PartrecToTM2.K') (q : Turing.PartrecToTM2.Λ'),
¬Turing.PartrecToTM2.Λ'.read f = Turing.PartrecToTM2.Λ'.move p k₁ k₂ q | null | false |
natCard_units_lt | Mathlib.RingTheory.Fintype | ∀ (M₀ : Type u_1) [inst : MonoidWithZero M₀] [Nontrivial M₀] [Finite M₀], Nat.card M₀ˣ < Nat.card M₀ | null | true |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft.0.Std.Tactic.BVDecide.BVExpr.bitblast.denote_blastShiftLeft._proof_1_6 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft | ∀ {w0 : ℕ} (idx n : ℕ), ¬0 ≤ n - 1 → False | null | false |
LowerSet.instDiv._proof_1 | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : Preorder α] [IsOrderedMonoid α] (s t : LowerSet α),
IsLowerSet (s.carrier / ↑t) | null | false |
Fin.val_fin_le | Mathlib.Data.Fin.Basic | ∀ {n : ℕ} {a b : Fin n}, ↑a ≤ ↑b ↔ a ≤ b | `a ≤ b` as natural numbers if and only if `a ≤ b` in `Fin n`. | true |
Submodule.coe_matrix | Mathlib.Data.Matrix.Basic | ∀ {m : Type u_2} {n : Type u_3} {R : Type u_14} {M : Type u_15} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] (S : Submodule R M), ↑S.matrix = (↑S).matrix | null | true |
le_of_inf_eq | Mathlib.Order.Lattice | ∀ {α : Type u} [inst : SemilatticeInf α] {a b : α}, a ⊓ b = a → a ≤ b | null | true |
Algebra.TensorProduct.basisAux._proof_4 | Mathlib.RingTheory.TensorProduct.Free | ∀ {R : Type u_1} (A : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
SMulCommClass R R A | null | false |
Lean.findParentProjStruct? | Lean.Structure | Lean.Environment → Lean.Name → Lean.Name → Option Lean.Name | Given a structure `structName` and a parent projection name `projName` (e.g. `toParentStructName`),
returns the corresponding parent structure name.
The parent projection name is a single-component name.
Note: this relies on the fact that projection names are checked to be consistent across all parents.
| true |
CategoryTheory.Limits.WidePullbackShape.struct._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {J : Type u_1} {Z : CategoryTheory.Limits.WidePullbackShape J}, Z = none → none = Z | null | false |
_private.Mathlib.Algebra.Free.0.FreeMagma.length_pos.match_1_1 | Mathlib.Algebra.Free | ∀ {α : Type u_1} (motive : FreeMagma α → Prop) (x : FreeMagma α),
(∀ (a : α), motive (FreeMagma.of a)) → (∀ (y z : FreeMagma α), motive (y.mul z)) → motive x | null | false |
Membership.mem.out | Mathlib.Data.Set.Operations | ∀ {α : Type u} {a : α} {p : α → Prop}, a ∈ {x | p x} → p a | If `h : a ∈ {x | p x}` then `h.out : p x`. These are definitionally equal, but this can
nevertheless be useful for various reasons, e.g. to apply further projection notation or in an
argument to `simp`. | true |
CategoryTheory.Limits.pullbackConeOfLeftIso_fst | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
[inst_1 : CategoryTheory.IsIso f],
(CategoryTheory.Limits.pullbackConeOfLeftIso f g).fst = CategoryTheory.CategoryStruct.comp g (CategoryTheory.inv f) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.