name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Algebra.Group.UniqueProds.Basic.0.instAddI.eq_1 | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ (G : Type u) (H : Type v) [inst : Add G] [inst_1 : Add H] (t : Bool), instAddI✝ G H t = Bool.rec ULift.add ULift.add t | null | true |
Localization.mk_eq_mk' | Mathlib.RingTheory.Localization.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R}, Localization.mk = IsLocalization.mk' (Localization M) | null | true |
AlgebraicGeometry.SheafedSpace.GlueData.mk.sizeOf_spec | Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : SizeOf C]
(toGlueData : CategoryTheory.GlueData (AlgebraicGeometry.SheafedSpace C))
(f_open : ∀ (i j : toGlueData.J), AlgebraicGeometry.SheafedSpace.IsOpenImmersion (toGlueData.f i j)),
sizeOf { toGlueData := toGlueData, f_open := f_open } = 1 + s... | null | true |
String.Slice.Pos.splits_copy_iff._simp_1 | Init.Data.String.Lemmas.Splits | ∀ {s : String.Slice} {p : s.Pos} {t₁ t₂ : String}, p.copy.Splits t₁ t₂ = p.Splits t₁ t₂ | null | false |
LinearMap.BilinForm.Isometry._aux_Mathlib_LinearAlgebra_BilinearForm_Isometry___unexpand_LinearMap_BilinForm_Isometry_1 | Mathlib.LinearAlgebra.BilinearForm.Isometry | Lean.PrettyPrinter.Unexpander | null | false |
CategoryTheory.PreZeroHypercover.pullbackCoverOfRightIsoPullback₂._proof_1 | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {Y : C} (E : CategoryTheory.PreZeroHypercover Y)
{X Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [inst_1 : CategoryTheory.Limits.HasPullback f g]
[∀ (i : E.I₀), CategoryTheory.Limits.HasPullback (CategoryTheory.Limits.pullback.snd f g) (E.f i)] (i : E.I₀),
Category... | null | false |
ProofWidgets.ExprWithCtx.expr | ProofWidgets.Compat | ProofWidgets.ExprWithCtx → Lean.Expr | null | true |
_private.Mathlib.Analysis.Normed.Group.Quotient.0.Ideal.Quotient.semiNormedCommRing._simp_4 | Mathlib.Analysis.Normed.Group.Quotient | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∃ x, p x) = ∃ a b, p (a, b) | null | false |
AddMemClass.mk._flat_ctor | Mathlib.Algebra.Group.Subsemigroup.Defs | ∀ {S : Type u_3} {M : outParam (Type u_4)} [inst : Add M] [inst_1 : SetLike S M],
(∀ {s : S} {a b : M}, a ∈ s → b ∈ s → a + b ∈ s) → AddMemClass S M | null | false |
Vector.setIfInBounds.eq_1 | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} (xs : Vector α n) (i : ℕ) (x : α),
xs.setIfInBounds i x = Vector.mk (xs.toArray.setIfInBounds i x) ⋯ | null | true |
Lean.Json._sizeOf_3 | Lean.Data.Json.Basic | Std.TreeMap.Raw String Lean.Json compare → ℕ | null | false |
Pell.xy_modEq_of_modEq | Mathlib.NumberTheory.PellMatiyasevic | ∀ {a b c : ℕ} (a1 : 1 < a) (b1 : 1 < b),
a ≡ b [MOD c] → ∀ (n : ℕ), Pell.xn a1 n ≡ Pell.xn b1 n [MOD c] ∧ Pell.yn a1 n ≡ Pell.yn b1 n [MOD c] | null | true |
Pell.Solution₁.exists_nontrivial_of_not_isSquare | Mathlib.NumberTheory.Pell | ∀ {d : ℤ}, 0 < d → ¬IsSquare d → ∃ a, a ≠ 1 ∧ a ≠ -1 | If `d` is a positive integer that is not a square, then there exists a nontrivial solution
to the Pell equation `x^2 - d*y^2 = 1`. | true |
_private.Mathlib.CategoryTheory.Monoidal.Preadditive.0.CategoryTheory.leftDistributor_assoc._simp_1_1 | Mathlib.CategoryTheory.Monoidal.Preadditive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {W X Y Z : C}
(f : W ⟶ X) (g : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.CategoryStruct.id Z) f)
(CategoryTheory.MonoidalCategoryStruct.... | null | false |
CategoryTheory.Pseudofunctor.DescentData.pullFunctorObjHom_eq | 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} {ι' : Type t'} {X' : ι' → C} {f' : (j : ι') → X' j ⟶ S'}
{α : ι' → ι} {p' : (j : ι') → ... | null | true |
Asymptotics.isBigO_snd_prod | Mathlib.Analysis.Asymptotics.Prod | ∀ {α : Type u_1} {E' : Type u_5} {F' : Type u_6} [inst : SeminormedAddCommGroup E'] [inst_1 : SeminormedAddCommGroup F']
{f' : α → E'} {g' : α → F'} {l : Filter α}, g' =O[l] fun x => (f' x, g' x) | null | true |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Cpop.0.Std.Tactic.BVDecide.BVExpr.bitblast.denote_blastCpopTree.go._proof_1_3 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Cpop | ∀ {w : ℕ} (len idx : ℕ), 1 < len → len = 1 → False | null | false |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.finitenessRelation | Init.Data.String.Pattern.String | {s : String.Slice} → Std.Iterators.FinitenessRelation (String.Slice.Pattern.ForwardSliceSearcher s) Id | null | true |
Metric.encard_maximalSeparatedSet | Mathlib.Topology.MetricSpace.CoveringNumbers | ∀ {X : Type u_1} [inst : PseudoEMetricSpace X] {A : Set X} {ε : NNReal},
Metric.packingNumber ε A ≠ ⊤ → (Metric.maximalSeparatedSet ε A).encard = Metric.packingNumber ε A | null | true |
Lean.Meta.InductionSubgoal.mvarId | Lean.Meta.Tactic.Induction | Lean.Meta.InductionSubgoal → Lean.MVarId | null | true |
CategoryTheory.ComposableArrows.threeδ₁Toδ₀._proof_2 | Mathlib.CategoryTheory.ComposableArrows.Three | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {i j k l : C} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l)
(f₁₂ : i ⟶ k),
CategoryTheory.CategoryStruct.comp f₁ f₂ = f₁₂ →
CategoryTheory.CategoryStruct.comp
((CategoryTheory.ComposableArrows.mk₂ f₁₂ f₃).map' 0 1 CategoryTheory.ComposableArrows.ho... | null | false |
quasiIsoAt_iff_exactAt | Mathlib.Algebra.Homology.QuasiIso | ∀ {ι : Type u_1} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {c : ComplexShape ι} {K L : HomologicalComplex C c} (f : K ⟶ L)
(i : ι) [inst_2 : K.HasHomology i] [inst_3 : L.HasHomology i], K.ExactAt i → (QuasiIsoAt f i ↔ L.ExactAt i) | null | true |
instCommRingCyclotomicRing._proof_25 | Mathlib.NumberTheory.Cyclotomic.Basic | ∀ (n : ℕ) (A : Type u_1) (K : Type u_2) [inst : CommRing A] [inst_1 : Field K] [inst_2 : Algebra A K]
(a : CyclotomicRing n A K), a * 0 = 0 | null | false |
_private.Mathlib.LinearAlgebra.QuadraticForm.Dual.0.LinearMap.BilinForm.linearIndependent_of_pairwise_le_zero._proof_1_4 | Mathlib.LinearAlgebra.QuadraticForm.Dual | ∀ {ι : Type u_1} {R : Type u_2} [inst : CommRing R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] (s : Finset ι)
(c : ι → R), Disjoint ({i ∈ s | 0 < c i}) ({i ∈ s | 0 < -c i}) | null | false |
AlgHom.isUnit_pullback_mk_iff | Mathlib.RingTheory.LocalRing.Pullback | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} {C : Type u_4} [inst : CommSemiring R] [inst_1 : Ring A]
[inst_2 : Algebra R A] [inst_3 : Ring B] [inst_4 : Algebra R B] [inst_5 : Semiring C] [inst_6 : Algebra R C]
(f : A →ₐ[R] C) (g : B →ₐ[R] C) {a : A × B} (a_in : a ∈ f.pullback g), IsUnit ⟨a, a_in⟩ ↔ IsUnit a.1 ∧ ... | null | true |
_private.Mathlib.Data.DFinsupp.BigOperators.0.DFinsupp.sumZeroHom._simp_1 | Mathlib.Data.DFinsupp.BigOperators | ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Multiset α}, (a ∈ s.toFinset) = (a ∈ s) | null | false |
AddSubgroup.relIndex_eq_abs_det | Mathlib.LinearAlgebra.FreeModule.Finite.CardQuotient | ∀ {E : Type u_1} [inst : AddCommGroup E] [inst_1 : Module ℚ E] (L₁ L₂ : AddSubgroup E),
L₁ ≤ L₂ →
∀ {ι : Type u_2} [inst_2 : DecidableEq ι] [inst_3 : Fintype ι] (b₁ b₂ : Module.Basis ι ℚ E),
L₁ = AddSubgroup.closure (Set.range ⇑b₁) →
L₂ = AddSubgroup.closure (Set.range ⇑b₂) → ↑(L₁.relIndex L₂) = |b₂... | null | true |
Lean.Parser.Term.letrec | Lean.Parser.Term | Lean.Parser.Parser | null | true |
LocallyConstant.instSub._proof_1 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : Sub Y] (f g : LocallyConstant X Y),
IsLocallyConstant (f.toFun - ⇑g) | null | false |
Finset.sigmaLift_mono | Mathlib.Data.Finset.Sigma | ∀ {ι : Type u_1} {α : ι → Type u_2} {β : ι → Type u_3} {γ : ι → Type u_4} [inst : DecidableEq ι]
{f g : ⦃i : ι⦄ → α i → β i → Finset (γ i)},
(∀ ⦃i : ι⦄ ⦃a : α i⦄ ⦃b : β i⦄, f a b ⊆ g a b) →
∀ (a : (i : ι) × α i) (b : (i : ι) × β i), Finset.sigmaLift f a b ⊆ Finset.sigmaLift g a b | null | true |
SSet.Truncated.instMonoidalTruncation | Mathlib.AlgebraicTopology.SimplicialSet.Monoidal | (n : ℕ) → (SSet.truncation n).Monoidal | null | true |
CategoryTheory.ChosenPullbacksAlong.cartesianMonoidalCategoryFst_pullback_obj | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(X Y : C) (Z : CategoryTheory.Over X),
(CategoryTheory.ChosenPullbacksAlong.pullback (CategoryTheory.SemiCartesianMonoidalCategory.fst X Y)).obj Z =
CategoryTheory.Over.mk (CategoryTheory.MonoidalCa... | null | true |
MonoidHom.compLeftContinuous._proof_2 | Mathlib.Topology.ContinuousMap.Algebra | ∀ (α : Type u_1) {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {γ : Type u_3}
[inst_2 : Monoid β] [inst_3 : ContinuousMul β] [inst_4 : TopologicalSpace γ] [inst_5 : Monoid γ]
[inst_6 : ContinuousMul γ] (g : β →* γ) (hg : Continuous ⇑g) (x x_1 : C(α, β)),
{ toFun := ⇑g, continuous_toFun ... | null | false |
_private.Mathlib.NumberTheory.RamificationInertia.Ramification.0.Ideal.ramificationIdx'_le_ramificationIdx'._simp_1_2 | Mathlib.NumberTheory.RamificationInertia.Ramification | ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] {T : Type u_3} [inst_2 : Semiring T] {I : Ideal R}
(f : R →+* S) (g : S →+* T), Ideal.map (g.comp f) I = Ideal.map g (Ideal.map f I) | null | false |
Lean.Elab.CompletionInfo._sizeOf_inst | Lean.Elab.InfoTree.Types | SizeOf Lean.Elab.CompletionInfo | null | false |
NonUnitalSubring.mk.inj | Mathlib.RingTheory.NonUnitalSubring.Defs | ∀ {R : Type u} {inst : NonUnitalNonAssocRing R} {toNonUnitalSubsemiring : NonUnitalSubsemiring R}
{neg_mem' : ∀ {x : R}, x ∈ toNonUnitalSubsemiring.carrier → -x ∈ toNonUnitalSubsemiring.carrier}
{toNonUnitalSubsemiring_1 : NonUnitalSubsemiring R}
{neg_mem'_1 : ∀ {x : R}, x ∈ toNonUnitalSubsemiring_1.carrier → -x ... | null | true |
_private.Mathlib.RingTheory.MvPowerSeries.Substitution.0.MvPowerSeries.HasSubst.pow._proof_1_1 | Mathlib.RingTheory.MvPowerSeries.Substitution | ∀ {n : ℕ}, n ≠ 0 → 0 < n | null | false |
Lean.Meta.Sym.DSimp.Context.casesOn | Lean.Meta.Sym.DSimp.DSimpM | {motive : Lean.Meta.Sym.DSimp.Context → Sort u} →
(t : Lean.Meta.Sym.DSimp.Context) → ((config : Lean.Meta.Sym.DSimp.Config) → motive { config := config }) → motive t | null | false |
Lean.JsonRpc.instInhabitedRequest | Lean.Data.JsonRpc | {a : Type u_1} → [Inhabited a] → Inhabited (Lean.JsonRpc.Request a) | null | true |
_private.Lean.Data.Json.FromToJson.Basic.0.Lean.NameMap.fromJson?.match_1 | Lean.Data.Json.FromToJson.Basic | (motive : Lean.Json → Sort u_1) →
(x : Lean.Json) →
((obj : Std.TreeMap.Raw String Lean.Json compare) → motive (Lean.Json.obj obj)) →
((j : Lean.Json) → motive j) → motive x | null | false |
Fin2.equivFin_symm_apply | Mathlib.Data.Fin.Fin2 | ∀ (n : ℕ) (i : Fin n), (Fin2.equivFin n).symm i = Fin2.ofFin i | null | true |
Nat.size_toArray_rco | Init.Data.Range.Polymorphic.NatLemmas | ∀ {a b : ℕ}, (a...b).toArray.size = b - a | null | true |
CategoryTheory.Iso.commRingCatIsoToRingEquiv_toRingHom | Mathlib.Algebra.Category.Ring.Basic | ∀ {R S : CommRingCat} (e : R ≅ S), ↑e.commRingCatIsoToRingEquiv = CommRingCat.Hom.hom e.hom | null | true |
Computation.Bind.g | Mathlib.Data.Seq.Computation | {α : Type u} → {β : Type v} → β ⊕ Computation β → β ⊕ Computation α ⊕ Computation β | bind over a `Sum` of `Computation` | true |
Std.DTreeMap.Internal.Impl.getKey!_union!_of_contains_eq_false_left | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [inst : Inhabited α]
[Std.TransOrd α],
m₁.WF → m₂.WF → ∀ {k : α}, Std.DTreeMap.Internal.Impl.contains k m₁ = false → (m₁.union! m₂).getKey! k = m₂.getKey! k | null | true |
_private.Mathlib.NumberTheory.Zsqrtd.Basic.0.Zsqrtd.nonnegg_cases_right.match_1_1 | Mathlib.NumberTheory.Zsqrtd.Basic | ∀ {c d a : ℕ} (motive : (x : ℤ) → (∀ (x_1 : ℕ), x = -↑x_1 → Zsqrtd.SqLe x_1 c a d) → Prop) (x : ℤ)
(x_1 : ∀ (x_1 : ℕ), x = -↑x_1 → Zsqrtd.SqLe x_1 c a d),
(∀ (b : ℕ) (x : ∀ (x : ℕ), ↑b = -↑x → Zsqrtd.SqLe x c a d), motive (Int.ofNat b) x) →
(∀ (b : ℕ) (h : ∀ (x : ℕ), Int.negSucc b = -↑x → Zsqrtd.SqLe x c a d), ... | null | false |
Lean.Meta.SimpTheorems._sizeOf_1 | Lean.Meta.Tactic.Simp.SimpTheorems | Lean.Meta.SimpTheorems → ℕ | null | false |
_private.Mathlib.GroupTheory.CoprodI.0.Monoid.CoprodI.NeWord.inv.match_1.eq_2 | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {G : ι → Type u_2} [inst : (i : ι) → Group (G i)]
(motive : (x x_1 : ι) → Monoid.CoprodI.NeWord G x x_1 → Sort u_3) (x x_1 j k : ι) (w₁ : Monoid.CoprodI.NeWord G x j)
(h : j ≠ k) (w₂ : Monoid.CoprodI.NeWord G k x_1)
(h_1 : (x : ι) → (x_2 : G x) → (h : x_2 ≠ 1) → motive x x (Monoid.CoprodI.NeWord.... | null | true |
NonUnitalSeminormedRing.induced._proof_12 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {F : Type u_3} (R : Type u_1) (S : Type u_2) [inst : FunLike F R S] [inst_1 : NonUnitalSeminormedRing S] (f : F),
Filter.comap (⇑f) (Bornology.cobounded S) ≤ Filter.cofinite | null | false |
Subfield.extendScalars.orderIso_apply | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {L : Type u_2} [inst : Field L] (F : Subfield L) (E : { E // F ≤ E }),
(Subfield.extendScalars.orderIso F) E = Subfield.extendScalars ⋯ | null | true |
_private.Mathlib.Analysis.Calculus.TaylorIntegral.0.map_add_eq_sum_add_integral_iteratedFDeriv._proof_1_10 | Mathlib.Analysis.Calculus.TaylorIntegral | Subsingleton (AddUnits ℕ∞) | null | false |
Lean.Linter.LintEntry.position?._default | Lean.Linter.PersistentLintLog | Option Lean.Position | null | false |
_private.Mathlib.AlgebraicGeometry.QuasiAffine.0.AlgebraicGeometry.Scheme.isPullback_toSpecΓ_toSpecΓ._simp_1_3 | Mathlib.AlgebraicGeometry.QuasiAffine | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : Z ⟶ Y} {g : Z ⟶ X},
(CategoryTheory.CategoryStruct.comp f α.inv = g) = (f = CategoryTheory.CategoryStruct.comp g α.hom) | null | false |
CategoryTheory.instFaithfulGrpFunctorOppositeGrpCatYonedaGrp | Mathlib.CategoryTheory.Monoidal.Cartesian.Grp | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C],
CategoryTheory.yonedaGrp.Faithful | null | true |
CategoryTheory.AddGrp.instAddMonObj._proof_2 | Mathlib.CategoryTheory.Monoidal.Cartesian.Grp | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {H : CategoryTheory.AddGrp C}
[inst_3 : CategoryTheory.IsCommAddMonObj H.X], CategoryTheory.IsAddMonHom CategoryTheory.AddMonObj.add.hom | null | false |
Set.mulOneClass | Mathlib.Algebra.Group.Pointwise.Set.Basic | {α : Type u_2} → [MulOneClass α] → MulOneClass (Set α) | `Set α` is a `MulOneClass` under pointwise operations if `α` is. | true |
CategoryTheory.Sieve.ext_iff | Mathlib.CategoryTheory.Sites.Sieves.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} {R S : CategoryTheory.Sieve X},
R = S ↔ ∀ ⦃Y : C⦄ (f : Y ⟶ X), R.arrows f ↔ S.arrows f | null | true |
Std.Async.Async.instMonadAsyncAsyncTask | Std.Async.Basic | Std.Async.MonadAsync Std.Async.AsyncTask Std.Async.Async | null | true |
Lean.Elab.Visibility._sizeOf_1 | Lean.Elab.DeclModifiers | Lean.Elab.Visibility → ℕ | null | false |
Nat.nth_eq_orderIsoOfNat | Mathlib.Data.Nat.Nth | ∀ {p : ℕ → Prop} (hf : (Set.ofPred p).Infinite), Nat.nth p = Subtype.val ∘ ⇑(Nat.Subtype.orderIsoOfNat (Set.ofPred p)) | When `s` is an infinite set, `nth` agrees with `Nat.Subtype.orderIsoOfNat`. | true |
BialgCat.noConfusionType | Mathlib.Algebra.Category.BialgCat.Basic | Sort u_1 →
{R : Type u} → [inst : CommRing R] → BialgCat R → {R' : Type u} → [inst' : CommRing R'] → BialgCat R' → Sort u_1 | null | false |
unitInterval.toNNReal._proof_1 | Mathlib.Topology.UnitInterval | ∀ (i : ↑unitInterval), 0 ≤ ↑i | null | false |
LinearMap.BilinMap.isSymm_iff_eq_flip | Mathlib.LinearAlgebra.SesquilinearForm.Basic | ∀ {R : Type u_1} {M : Type u_5} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_20}
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] {B : LinearMap.BilinMap R M N},
(∀ (x y : M), (B x) y = (B y) x) ↔ B = LinearMap.flip B | null | true |
_private.Mathlib.Algebra.Group.ModEq.0.AddCommGroup.modEq_zero._simp_1_1 | Mathlib.Algebra.Group.ModEq | ∀ {M : Type u_1} [inst : AddCommMonoid M] {a b p : M}, (a ≡ b [PMOD p]) = ∃ m n, m • p + a = n • p + b | null | false |
Finset.inf_sup | Mathlib.Data.Finset.Lattice.Pi | ∀ {α : Type u_1} {ι : Type u_2} [inst : DistribLattice α] [inst_1 : BoundedOrder α] [inst_2 : DecidableEq ι]
{κ : ι → Type u_3} (s : Finset ι) (t : (i : ι) → Finset (κ i)) (f : (i : ι) → κ i → α),
(s.inf fun i => (t i).sup (f i)) = (s.pi t).sup fun g => s.attach.inf fun i => f (↑i) (g ↑i ⋯) | null | true |
LieSubmodule.coe_map_toEnd_le | Mathlib.Algebra.Lie.OfAssociative | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
{N : LieSubmodule R L M} {x : L}, Submodule.map ((LieModule.toEnd R L M) x) ↑N ≤ ↑N | null | true |
AdicCompletion.evalₐ._proof_1 | Mathlib.RingTheory.AdicCompletion.Algebra | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) (n : ℕ), I ^ n • ⊤ = I ^ n | null | false |
Sym.map._proof_1 | Mathlib.Data.Sym.Basic | ∀ {α : Type u_2} {β : Type u_1} {n : ℕ} (f : α → β) (x : Sym α n), (Multiset.map f ↑x).card = n | null | false |
DerivedCategory.instPreadditive._proof_3 | Mathlib.Algebra.Homology.DerivedCategory.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C],
(HomotopyCategory.subcategoryAcyclic C).trW.HasLeftCalculusOfFractions | null | false |
NormedSpace.inclusionInDoubleDualWeak._proof_1 | Mathlib.Analysis.Normed.Module.DoubleDual | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜], ContinuousAdd 𝕜 | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Finite.0.SimpleGraph.neighborFinset_eq_empty._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Finite | ∀ {α : Type u} {a b : Set α}, (a = b) = ∀ (x : α), x ∈ a ↔ x ∈ b | null | false |
_private.Mathlib.RingTheory.PowerSeries.Ideal.0.PowerSeries.eq_span_insert_X_of_X_mem_of_span_eq._simp_1_1 | Mathlib.RingTheory.PowerSeries.Ideal | ∀ {α : Type u} [inst : Semiring α] {s : Set α} {I : Ideal α}, (Ideal.span s ≤ I) = (s ⊆ ↑I) | null | false |
IsLocalization.Away.awayToAwayLeft._proof_1 | Mathlib.RingTheory.Localization.Away.Basic | ∀ {R : Type u_2} [inst : CommSemiring R] {P : Type u_1} [inst_1 : CommSemiring P] (x y : R) [inst_2 : Algebra R P]
[IsLocalization.Away (y * x) P], IsUnit ((algebraMap R P) x) | null | false |
SymbolicDynamics.FullShift.MulSubshift | Mathlib.Dynamics.SymbolicDynamics.Basic | (A : Type u_1) → [TopologicalSpace A] → (G : Type u_2) → [Monoid G] → Type (max u_1 u_2) | A *subshift* on an alphabet `A` over a multiplicative monoid `G` is a closed,
shift-invariant subset of `G → A`, where the shift is given by left-multiplication.
Formally, it is composed of:
* `carrier`: the underlying set of allowed configurations.
* `isClosed`: the set is topologically closed in `A^G`.
* `mapsTo`: th... | true |
Std.DHashMap.Raw.Const.get!_insertMany_list_of_mem | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β} [EquivBEq α]
[LawfulHashable α] [inst_4 : Inhabited β],
m.WF →
∀ {l : List (α × β)} {k k' : α},
(k == k') = true →
∀ {v : β},
List.Pairwise (fun a b => (a.1 == b.1) = false) l →
... | null | true |
Mathlib.Meta.Positivity.core | Mathlib.Tactic.Positivity.Core | {u : Lean.Level} →
{α : Q(Type u)} →
(zα : Q(Zero «$α»)) →
(pα? : Option Q(PartialOrder «$α»)) → (e : Q(«$α»)) → Lean.MetaM (Mathlib.Meta.Positivity.Strictness zα e pα?) | Run each registered `positivity` extension on an expression, returning a `NormNum.Result`. | true |
Finset.expectWith_congr | Mathlib.Algebra.BigOperators.Expect | ∀ {ι : Type u_1} {M : Type u_4} [inst : AddCommMonoid M] [inst_1 : Module ℚ≥0 M] {s t : Finset ι} {f g : ι → M}
{p q : ι → Prop} [inst_2 : DecidablePred p] [inst_3 : DecidablePred q],
s = t →
(∀ i ∈ t, p i ↔ q i) →
(∀ i ∈ t, q i → f i = g i) → ({i ∈ s | p i}.expect fun i => f i) = {i ∈ t | q i}.expect fun... | null | true |
Real.Angle.sin_toReal | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ (θ : Real.Angle), Real.sin θ.toReal = θ.sin | null | true |
Aesop.Script.StaticStructureM.Context.casesOn | Aesop.Script.StructureStatic | {motive : Aesop.Script.StaticStructureM.Context → Sort u} →
(t : Aesop.Script.StaticStructureM.Context) →
((steps : Std.HashMap Lean.MVarId (ℕ × Aesop.Script.Step)) → motive { steps := steps }) → motive t | null | false |
AlgebraicGeometry.Scheme.Hom.normalizationPullback._proof_3 | Mathlib.AlgebraicGeometry.Normalization | ∀ {X S Y : AlgebraicGeometry.Scheme} (f : X ⟶ S) (g : Y ⟶ S) [inst : AlgebraicGeometry.QuasiCompact f]
[inst_1 : AlgebraicGeometry.QuasiSeparated f],
CategoryTheory.Limits.pullback.snd f g =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.pullback.map f g (AlgebraicGeometry.Scheme.Hom.fromNormal... | null | false |
Lean.Meta.LazyDiscrTree.ImportData.mk.inj | Lean.Meta.LazyDiscrTree | ∀ {errors errors_1 : IO.Ref (Array Lean.Meta.LazyDiscrTree.ImportFailure)},
{ errors := errors } = { errors := errors_1 } → errors = errors_1 | null | true |
_private.Mathlib.Basic.IsEmpty.Basic.0.isEmpty_pi._simp_1_3 | Mathlib.Basic.IsEmpty.Basic | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | null | false |
circleIntegrable_congr | Mathlib.MeasureTheory.Integral.CircleIntegral | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] {c : ℂ} {R : ℝ} {f₁ f₂ : ℂ → E},
Set.EqOn f₁ f₂ (Metric.sphere c |R|) → (CircleIntegrable f₁ c R ↔ CircleIntegrable f₂ c R) | Circle integrability depends only on the restriction of the function to the sphere.
| true |
spectralNorm.metricSpace | Mathlib.Analysis.Normed.Unbundled.SpectralNorm | (K : Type u) →
[inst : NontriviallyNormedField K] →
(L : Type v) →
[inst_1 : Field L] →
[inst_2 : Algebra K L] →
[Algebra.IsAlgebraic K L] → [hu : IsUltrametricDist K] → [CompleteSpace K] → MetricSpace L | The metric space structure on `L` induced by the spectral norm. | true |
Real.Lp.fourierTransformInvCLM._proof_4 | Mathlib.Analysis.Fourier.FourierTransform | RingHomCompTriple (RingHom.id ℂ) (RingHom.id ℂ) (RingHom.id ℂ) | null | false |
FormalMultilinearSeries.le_radius_pi | Mathlib.Analysis.Analytic.Constructions | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {ι : Type u_9} [inst_3 : Fintype ι] {Fm : ι → Type u_10}
[inst_4 : (i : ι) → NormedAddCommGroup (Fm i)] [inst_5 : (i : ι) → NormedSpace 𝕜 (Fm i)] {r : ENNReal}
{p : (i : ι) → FormalMul... | null | true |
Polynomial.recOnHorner._proof_7 | Mathlib.Algebra.Polynomial.Inductions | ∀ {R : Type u_1} [inst : Semiring R] (p : Polynomial R), ¬p = 0 → p.coeff 0 = 0 → p.divX = 0 → False | null | false |
Batteries.BinomialHeap.Imp.Heap.headD.eq_def | Batteries.Data.BinomialHeap.Lemmas | ∀ {α : Type u_1} (le : α → α → Bool) (a : α) (x : Batteries.BinomialHeap.Imp.Heap α),
Batteries.BinomialHeap.Imp.Heap.headD le a x =
match x with
| Batteries.BinomialHeap.Imp.Heap.nil => a
| Batteries.BinomialHeap.Imp.Heap.cons rank b node hs =>
Batteries.BinomialHeap.Imp.Heap.headD le (if le a b = ... | null | true |
_private.Mathlib.Analysis.Complex.CanonicalDecomposition.0.Complex.CanonicalDecomp.divisor_eq_divisor._simp_1_7 | Mathlib.Analysis.Complex.CanonicalDecomposition | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) | null | false |
WithOne.lift_unique | Mathlib.Algebra.Group.WithOne.Basic | ∀ {α : Type u} {β : Type v} [inst : Mul α] [inst_1 : MulOneClass β] (f : WithOne α →* β),
f = WithOne.lift ((↑f).comp WithOne.coeMulHom) | null | true |
_private.Mathlib.Analysis.Meromorphic.NormalForm.0.meromorphicNFAt_comp_iff_of_deriv_ne_zero._simp_1_1 | Mathlib.Analysis.Meromorphic.NormalForm | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f : 𝕜 → E} {x : 𝕜},
MeromorphicNFAt f x = (AnalyticAt 𝕜 f x ∨ MeromorphicAt f x ∧ meromorphicOrderAt f x < 0 ∧ f x = 0) | null | false |
DiffeologicalSpace.self_subset_toPlots_generateFrom | Mathlib.Geometry.Diffeology.Basic | ∀ {X : Type u_1} (g : Set ((n : ℕ) × (EuclideanSpace ℝ (Fin n) → X))), g ⊆ (DiffeologicalSpace.generateFrom g).toPlots | null | true |
Bool.true_eq_false_eq_False | Mathlib.Data.Bool.Basic | ¬true = false | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin.0._regBuiltin.Fin.reduceNe.declare_131._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin.989699173._hygCtx._hyg.28 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin | IO Unit | null | false |
CategoryTheory.PreservesFiniteLimitsOfFlat.lift.eq_1 | Mathlib.CategoryTheory.Functor.Flat | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{J : Type v₁} [inst_2 : CategoryTheory.SmallCategory J] [inst_3 : CategoryTheory.FinCategory J]
{K : CategoryTheory.Functor J C} (F : CategoryTheory.Functor C D) [inst_4 : CategoryTheory.Represent... | null | true |
Nat.digits | Mathlib.Data.Nat.Digits.Defs | ℕ → ℕ → List ℕ | `digits b n` gives the digits, in little-endian order,
of a natural number `n` in a specified base `b`.
In any base, we have `ofDigits b L = L.foldr (fun x y ↦ x + b * y) 0`.
* For any `2 ≤ b`, we have `l < b` for any `l ∈ digits b n`,
and the last digit is not zero.
This uniquely specifies the behaviour of `digit... | true |
_private.Mathlib.Tactic.Setm.0.Mathlib.Tactic.SetM.replaceWithLDecls.createLDecl | Mathlib.Tactic.Setm | Lean.Syntax → Lean.Name → Mathlib.Tactic.SetM.SetMReplaceM✝ Lean.FVarId | null | true |
Multiset.consEquiv_symm_some | Mathlib.Data.Multiset.Fintype | ∀ {α : Type u_1} [inst : DecidableEq α] {m : Multiset α} {v : α} {x : m.ToType},
Multiset.consEquiv.symm (some x) = ⟨x.fst, Fin.castLE ⋯ x.snd⟩ | null | true |
RingInvoClass.casesOn | Mathlib.RingTheory.RingInvo | {F : Type u_3} →
{R : Type u_4} →
[inst : Semiring R] →
[inst_1 : EquivLike F R Rᵐᵒᵖ] →
{motive : RingInvoClass F R → Sort u} →
(t : RingInvoClass F R) →
([toRingEquivClass : RingEquivClass F R Rᵐᵒᵖ] →
(involution : ∀ (f : F) (x : R), MulOpposite.unop (f (MulOpp... | null | false |
Lean.mkMData | Lean.Expr | Lean.MData → Lean.Expr → Lean.Expr | `.mdata m e` is now the preferred form.
| true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.