name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Real.cos_nat_mul_two_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (n : ℕ), Real.cos (↑n * (2 * Real.pi)) = 1 | null | true |
Lean.Elab.InlayHintLabel.toLspInlayHintLabel | Lean.Server.FileWorker.InlayHints | Lean.FileMap → Lean.Elab.InlayHintLabel → IO Lean.Lsp.InlayHintLabel | null | true |
SelbergSieve.casesOn | Mathlib.NumberTheory.SelbergSieve | {motive : SelbergSieve → Sort u} →
(t : SelbergSieve) →
((toBoundingSieve : BoundingSieve) →
(level : ℝ) →
(one_le_level : 1 ≤ level) →
motive { toBoundingSieve := toBoundingSieve, level := level, one_le_level := one_le_level }) →
motive t | null | false |
Units.divp_add_divp | Mathlib.Algebra.Ring.Units | ∀ {α : Type u} [inst : CommSemiring α] (a b : α) (u₁ u₂ : αˣ), a /ₚ u₁ + b /ₚ u₂ = (a * ↑u₂ + ↑u₁ * b) /ₚ (u₁ * u₂) | null | true |
SimpleGraph.Finsubgraph.coe_sup._simp_1 | Mathlib.Combinatorics.SimpleGraph.Finsubgraph | ∀ {V : Type u} {G : SimpleGraph V} (G₁ G₂ : G.Finsubgraph), ↑G₁ ⊔ ↑G₂ = ↑(G₁ ⊔ G₂) | null | false |
Std.DTreeMap.Internal.Cell.property | Std.Data.DTreeMap.Internal.Cell | ∀ {α : Type u} [inst : Ord α] {β : α → Type v} {k : α → Ordering} (self : Std.DTreeMap.Internal.Cell α β k)
[Std.OrientedOrd α] (p : (a : α) × β a), self.inner = some p → k p.fst = Ordering.eq | If there is a mapping, then it has a matching key. | true |
Finset.dens_smul_finset | Mathlib.Algebra.Group.Pointwise.Finset.Density | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] [inst_1 : Group α] [inst_2 : MulAction α β] [inst_3 : Fintype β]
(a : α) (s : Finset β), (a • s).dens = s.dens | null | true |
ContinuousLinearMap.differentiableAt | Mathlib.Analysis.Calculus.FDeriv.Linear | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] (f : E →L[𝕜] F) {x : E}, DifferentiableAt 𝕜 (⇑f) x | null | true |
CategoryTheory.Core.isoMk_inv_iso | Mathlib.CategoryTheory.Core | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {x y : CategoryTheory.Core C} (e : x.of ≅ y.of),
(CategoryTheory.Core.isoMk e).inv.iso = e.symm | null | true |
Lean.Grind.Config.revert._default | Init.Grind.Config | Bool | null | false |
WeierstrassCurve.Projective.addZ | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | {R : Type r} → [CommRing R] → WeierstrassCurve.Projective R → (Fin 3 → R) → (Fin 3 → R) → R | The `Z`-coordinate of a representative of `P + Q` for two distinct projective point
representatives `P` and `Q` on a Weierstrass curve.
If the representatives of `P` and `Q` are equal, then this returns the value `0`. | true |
_private.Mathlib.Data.Finset.Powerset.0.Finset.pairwiseDisjoint_pair_insert._simp_1_8 | Mathlib.Data.Finset.Powerset | ∀ {a b c : Prop}, (a ∨ b → c) = ((a → c) ∧ (b → c)) | null | false |
List.findFinIdx?.eq_1 | Init.Data.List.Find | ∀ {α : Type u} (p : α → Bool) (l : List α), List.findFinIdx? p l = List.findFinIdx?.go p l l 0 ⋯ | null | true |
Lean.IR.instInhabitedCtorInfo | Lean.Compiler.IR.Basic | Inhabited Lean.IR.CtorInfo | null | true |
List.erase_eq_self_iff_forall_bne | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α] (a : α) (xs : List α), xs.erase a = xs ↔ ∀ x ∈ xs, ¬(x == a) = true | null | true |
Std.Do.PredTrans.bind._proof_1 | Std.Do.PredTrans | ∀ {ps : Std.Do.PostShape} {α β : Type u_1} (x : Std.Do.PredTrans ps α) (f : α → Std.Do.PredTrans ps β),
Std.Do.PredTrans.Conjunctive fun Q => x.apply (fun a => (f a).apply Q, Q.2) | null | false |
CategoryTheory.Oplax.OplaxTrans.StrongCore.noConfusionType | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Oplax | Sort u →
{B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.OplaxFunctor B C} →
{η : F ⟶ G} →
CategoryTheory.Oplax.OplaxTrans.StrongCore η →
{B' : Type u₁} →
... | null | false |
MonoidAlgebra.single_right_inj | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] {r₁ r₂ : R} {m : M},
MonoidAlgebra.single m r₁ = MonoidAlgebra.single m r₂ ↔ r₁ = r₂ | null | true |
Rat.den_normalize | Init.Data.Rat.Lemmas | ∀ {num : ℤ} {den : ℕ} (den_nz : den ≠ 0), (Rat.normalize num den den_nz).den = den / num.natAbs.gcd den | null | true |
_private.Mathlib.Tactic.Linter.FlexibleLinter.0.Mathlib.Linter.Flexible.flexibleLinter.match_5 | Mathlib.Tactic.Linter.FlexibleLinter | (motive : Mathlib.Linter.Flexible.Stained✝ → Sort u_1) →
(d : Mathlib.Linter.Flexible.Stained✝) →
(Unit → motive Mathlib.Linter.Flexible.Stained.wildcard✝) →
((x : Mathlib.Linter.Flexible.Stained✝) → motive x) → motive d | null | false |
Std.CloseableChannel.Error.ctorIdx | Std.Sync.Channel | Std.CloseableChannel.Error → ℕ | null | false |
TypeVec.typevecCasesCons₂_appendFun | Mathlib.Data.TypeVec | ∀ (n : ℕ) (t : Type u_1) (t' : Type u_2) (v : TypeVec.{u_1} n) (v' : TypeVec.{u_2} n)
{β : (v ::: t).Arrow (v' ::: t') → Sort u_3} (F : (f : t → t') → (fs : v.Arrow v') → β (fs ::: f)) (f : t → t')
(fs : v.Arrow v'), TypeVec.typevecCasesCons₂ n t t' v v' F (fs ::: f) = F f fs | null | true |
_private.Mathlib.SetTheory.ZFC.Basic.0.ZFSet.mem_image.match_1_1 | Mathlib.SetTheory.ZFC.Basic | ∀ {f : ZFSet.{u_1} → ZFSet.{u_1}} [inst : ZFSet.Definable₁ f] (x : PSet.{u_1}) («Type» : Type u_1)
(A : «Type» → PSet.{u_1}) (motive : ⟦x⟧ ∈ ZFSet.image f ⟦{ «Type» := «Type», Func := A }⟧ → Prop)
(x_1 : ⟦x⟧ ∈ ZFSet.image f ⟦{ «Type» := «Type», Func := A }⟧),
(∀ (a : (PSet.image (ZFSet.Definable₁.out f) { «Type» ... | null | false |
AddUnits.val_vadd | Mathlib.Algebra.Group.Action.Units | ∀ {G : Type u_1} {M : Type u_3} [inst : AddGroup G] [inst_1 : AddMonoid M] [inst_2 : AddAction G M]
[inst_3 : VAddCommClass G M M] [inst_4 : VAddAssocClass G M M] (g : G) (m : AddUnits M), ↑(g +ᵥ m) = g +ᵥ ↑m | null | true |
CategoryTheory.TwoSquare.equivNatTrans | Mathlib.CategoryTheory.Functor.TwoSquare | {C₁ : Type u₁} →
{C₂ : Type u₂} →
{C₃ : Type u₃} →
{C₄ : Type u₄} →
[inst : CategoryTheory.Category.{v₁, u₁} C₁] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C₃] →
[inst_3 : CategoryTheory.Category.{v₄, u₄} C₄] →
... | The type of 2-squares on functors `T`, `L`, `R`, and `B` is trivially equivalent to
the type of natural transformations `T ⋙ R ⟶ L ⋙ B`. | true |
AddEquiv.cast | Mathlib.Algebra.Group.Equiv.Defs | {ι : Type u_9} → {M : ι → Type u_10} → [inst : (i : ι) → Add (M i)] → {i j : ι} → i = j → M i ≃+ M j | `Equiv.cast (congrArg _ h)` as an `AddEquiv`.
Note that unlike `Equiv.cast`, this takes an equality of indices rather than an equality of types,
to avoid having to deal with an equality of the algebraic structure itself. | true |
List.prod_pair | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : One α] [Std.LawfulRightIdentity (fun x1 x2 => x1 * x2) 1] {a b : α},
[a, b].prod = a * b | null | true |
Finset.eraseInduction | Mathlib.Data.Finset.Card | ∀ {α : Type u_1} [inst : DecidableEq α] {p : Finset α → Prop},
(∀ (S : Finset α), (∀ s ∈ S, p (S.erase s)) → p S) → ∀ (S : Finset α), p S | To prove a proposition for an arbitrary `Finset α`,
it suffices to prove that for any `S : Finset α`, the following is true:
the property is true for S with any element `s` removed, then the property holds for `S`.
This is a weaker version of `Finset.strongInduction`.
But it can be more precise when the induction argu... | true |
_private.Mathlib.SetTheory.Cardinal.HasCardinalLT.0.hasCardinalLT_subtype_iSup.match_1_1 | Mathlib.SetTheory.Cardinal.HasCardinalLT | {ι : Type u_1} →
{X : Type u_2} →
(P : ι → X → Prop) →
(motive : (i : ι) × Subtype (P i) → Sort u_3) →
(x : (i : ι) × Subtype (P i)) → ((i : ι) → (x : X) → (hx : P i x) → motive ⟨i, ⟨x, hx⟩⟩) → motive x | null | false |
_private.Mathlib.Data.Nat.Digits.Defs.0.Nat.toDigitsCore.match_1.splitter | Mathlib.Data.Nat.Digits.Defs | (motive : ℕ → ℕ → List Char → Sort u_1) →
(x x_1 : ℕ) →
(x_2 : List Char) →
((x : ℕ) → (ds : List Char) → motive 0 x ds) →
((fuel n : ℕ) → (ds : List Char) → motive fuel.succ n ds) → motive x x_1 x_2 | null | true |
Real.not_summable_one_div_natCast | Mathlib.Analysis.PSeries | ¬Summable fun n => 1 / ↑n | Harmonic series is not unconditionally summable. | true |
CategoryTheory.Sieve.ofObjects_id | Mathlib.CategoryTheory.Sites.Sieves.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (X : C), CategoryTheory.Sieve.ofObjects id X = ⊤ | null | true |
Lean.Elab.GoalsAtResult.priority | Lean.Elab.InfoTree.Util | Lean.Elab.GoalsAtResult → ℕ | null | true |
CategoryTheory.Limits.equalizerIsEqualizer.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u} {X Y : C} [inst : CategoryTheory.Category.{v, u} C] (f g : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasEqualizer f g],
CategoryTheory.Limits.equalizerIsEqualizer f g =
(CategoryTheory.Limits.limit.isLimit (CategoryTheory.Limits.parallelPair f g)).ofIsoLimit
(CategoryTheory.Limits.Fork.ext
... | null | true |
_private.Mathlib.Analysis.Convex.Side.0.AffineSubspace.wSameSide_comm.match_1_3 | 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 y : P} (motive : s.WSameSide y x → Prop) (x_1 : s.WSameSide y x),
(∀ (p₁ : P) (hp₁ : p₁... | null | false |
OrderEmbedding.withTopMap.eq_1 | Mathlib.Order.Hom.WithTopBot | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (f : α ↪o β),
f.withTopMap =
{ toEmbedding := { toFun := WithTop.map ⇑f, inj' := ⋯, map_rel_iff' := ⋯ }.toEmbedding, map_rel_iff' := ⋯ } | null | true |
LinearMap.baseChange_tmul | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ {R : Type u_1} {A : Type u_2} {M : Type u_4} {N : Type u_5} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : AddCommMonoid N] [inst_5 : Module R M]
[inst_6 : Module R N] (f : M →ₗ[R] N) (a : A) (x : M), (LinearMap.baseChange A f) (a ⊗ₜ[R] x) = a ⊗ₜ[R] f x | null | true |
Mathlib.Tactic.ITauto.Proof.curry.elim | Mathlib.Tactic.ITauto | {motive : Mathlib.Tactic.ITauto.Proof → Sort u} →
(t : Mathlib.Tactic.ITauto.Proof) →
t.ctorIdx = 8 →
((ak : Mathlib.Tactic.ITauto.AndKind) →
(p : Mathlib.Tactic.ITauto.Proof) → motive (Mathlib.Tactic.ITauto.Proof.curry ak p)) →
motive t | null | false |
ProbabilityTheory.«_aux_Mathlib_Probability_Independence_Conditional___macroRules_ProbabilityTheory_term_⟂ᵢ[_,_;_]__1» | Mathlib.Probability.Independence.Conditional | Lean.Macro | null | false |
antitoneOn_of_add_one_le | Mathlib.Algebra.Order.SuccPred | ∀ {α : Type u_2} {β : Type u_3} [inst : PartialOrder α] [inst_1 : Preorder β] [inst_2 : Add α] [inst_3 : One α]
[inst_4 : SuccAddOrder α] [IsSuccArchimedean α] {s : Set α} {f : α → β},
s.OrdConnected → (∀ (a : α), ¬IsMax a → a ∈ s → a + 1 ∈ s → f (a + 1) ≤ f a) → AntitoneOn f s | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Acyclic.0.SimpleGraph.IsTree.card_edgeFinset._proof_1_2 | Mathlib.Combinatorics.SimpleGraph.Acyclic | ∀ {V : Type u_1} {G : SimpleGraph V} (inhabited_h : Inhabited V) (f : (x : V) → G.Walk x default) (a b : V),
(f a).length ≤ (f b).length → (f a).length = (f b).length + 1 → a = b | null | false |
norm_eq_sqrt_re_inner | Mathlib.Analysis.InnerProductSpace.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(x : E), ‖x‖ = √(RCLike.re (inner 𝕜 x x)) | null | true |
SemiRingCat.FilteredColimits.semiringObj._proof_7 | Mathlib.Algebra.Category.Ring.FilteredColimits | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J SemiRingCat) (j : J)
(a : ((F.comp (CategoryTheory.forget₂ SemiRingCat MonCat)).comp (CategoryTheory.forget MonCat)).obj j), a + 0 = a | null | false |
List.decidableSubperm | Batteries.Data.List.Perm | {α : Type u_1} → [inst : BEq α] → [LawfulBEq α] → DecidableRel fun x1 x2 => x1.Subperm x2 | null | true |
ProbabilityTheory.Kernel.definition._@.Mathlib.Probability.Kernel.RadonNikodym.743833221._hygCtx._hyg.2 | Mathlib.Probability.Kernel.RadonNikodym | {α : Type u_1} →
{γ : Type u_2} →
{mα : MeasurableSpace α} →
{mγ : MeasurableSpace γ} →
[hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ] →
(κ η : ProbabilityTheory.Kernel α γ) →
[ProbabilityTheory.IsSFiniteKernel κ] → [ProbabilityTheory.IsSFiniteKernel η] → Probability... | null | false |
_private.Mathlib.MeasureTheory.SetSemiring.0.MeasureTheory.IsSetSemiring.sUnion_disjointOfUnion._simp_1_3 | Mathlib.MeasureTheory.SetSemiring | ∀ {α : Type u_2} (s : Finset (Set α)), ⋃₀ ↑s = s.sup id | null | false |
CategoryTheory.Functor.curry₃ObjProdComp._proof_4 | Mathlib.CategoryTheory.Functor.CurryingThree | ∀ {C₁ : Type u_8} {C₂ : Type u_2} {C₃ : Type u_3} {D₁ : Type u_12} {D₂ : Type u_13} {D₃ : Type u_14} {E : Type u_5}
[inst : CategoryTheory.Category.{u_7, u_8} C₁] [inst_1 : CategoryTheory.Category.{u_1, u_2} C₂]
[inst_2 : CategoryTheory.Category.{u_6, u_3} C₃] [inst_3 : CategoryTheory.Category.{u_9, u_12} D₁]
[in... | null | false |
_private.Mathlib.CategoryTheory.Sites.Coverage.0.CategoryTheory.Coverage.saturate_iff_saturate_toPrecoverage._proof_1_4 | Mathlib.CategoryTheory.Sites.Coverage | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] (X_1 X_2 : C),
X_1 = X_2 → CategoryTheory.Presieve X_2 = CategoryTheory.Presieve X_1 | null | false |
ContinuousOn.cfc_nnreal'._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity | Lean.Syntax | null | false |
FinEnum.Finset.enum.eq_1 | Mathlib.Data.FinEnum | ∀ {α : Type u} [inst : DecidableEq α], FinEnum.Finset.enum [] = [∅] | null | true |
List.findIdx.go | Init.Data.List.Basic | {α : Type u} → (α → Bool) → List α → ℕ → ℕ | Auxiliary for `findIdx`: `findIdx.go p l n = findIdx p l + n` | true |
ContMDiffAt.finsum_section_of_locallyFinite | Mathlib.Geometry.Manifold.VectorBundle.ContMDiffSection | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {F : Type u_5} [inst_6 : NormedAddCommG... | null | true |
Lean.Lsp.MessageActionItem.mk.injEq | Lean.Data.Lsp.Window | ∀ (title title_1 : String), ({ title := title } = { title := title_1 }) = (title = title_1) | null | true |
«_aux_Init_Notation___macroRules_term_$___1» | Init.Notation | Lean.Macro | null | false |
Manifold.IsSubmersionAt.congr_of_eventuallyEq | Mathlib.Geometry.Manifold.Submersion | ∀ {𝕜 : Type u_1} {E'' : Type u_3} {H : Type u_7} {G : Type u_9} {E : Type u} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup E'']
[inst_4 : NormedSpace 𝕜 E''] [inst_5 : TopologicalSpace H] [inst_6 : TopologicalSpace G] {I : ModelWithCorn... | If `f` is a submersion at `x` and `g = f` on some neighbourhood of `x`,
then `g` is a submersion at `x`. | true |
List.support_formPerm_le | Mathlib.GroupTheory.Perm.List | ∀ {α : Type u_1} [inst : DecidableEq α] (l : List α) [inst_1 : Fintype α], l.formPerm.support ⊆ l.toFinset | null | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Reflexive.0.CategoryTheory.Limits.reflexivePair.match_1.eq_2 | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | ∀ (motive : CategoryTheory.Limits.WalkingReflexivePair → Sort u_1)
(h_1 : Unit → motive CategoryTheory.Limits.WalkingReflexivePair.zero)
(h_2 : Unit → motive CategoryTheory.Limits.WalkingReflexivePair.one),
(match CategoryTheory.Limits.WalkingReflexivePair.one with
| CategoryTheory.Limits.WalkingReflexivePair... | null | true |
_private.Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion.0.Tactic.ComputeAsymptotics.Seq.FriendlyOperation.coind_comp_friend_right.match_1_1.splitter | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion | {α : Type u_1} →
(motive : Option (α × Subtype Tactic.ComputeAsymptotics.Seq.FriendlyOperation) → Sort u_2) →
(x : Option (α × Subtype Tactic.ComputeAsymptotics.Seq.FriendlyOperation)) →
(Unit → motive none) →
((hd : α) → (opf' : Subtype Tactic.ComputeAsymptotics.Seq.FriendlyOperation) → motive (som... | null | true |
_private.Mathlib.CategoryTheory.Limits.Cones.0.CategoryTheory.Limits.ConeMorphism.hom_inv_id._simp_1_1 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} {X Y Z : CategoryTheory.Limits.Cone F} (f : CategoryTheory.Limits.ConeMorphism X Y)
(g : CategoryTheory.Limits.ConeMorphism Y Z),
CategoryTheory.CategoryStruct.c... | null | false |
_private.Mathlib.LinearAlgebra.Matrix.Circulant.0.Matrix.circulant_single._simp_1_1 | Mathlib.LinearAlgebra.Matrix.Circulant | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
_private.Std.Sync.Broadcast.0.Std.Bounded.mk.inj | Std.Sync.Broadcast | ∀ {α : Type} {state state_1 : Std.Mutex (Std.Bounded.State✝ α)},
{ state := state } = { state := state_1 } → state = state_1 | null | true |
AlgebraicGeometry.Proj.pullbackAwayιIso.congr_simp | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Basic | ∀ {σ : Type u_1} {A : Type u} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubgroupClass σ A] (𝒜 : ℕ → σ)
[inst_3 : GradedRing 𝒜] {f : A} {m : ℕ} (f_deg : f ∈ 𝒜 m) (hm : 0 < m) {m' : ℕ} {g : A} (g_deg : g ∈ 𝒜 m')
(hm' : 0 < m') {x : A} (hx : x = f * g),
AlgebraicGeometry.Proj.pullbackAwayιIso 𝒜 f_... | null | true |
Rep.instEpiModuleCatToModuleCatHom | Mathlib.RepresentationTheory.Rep.Basic | ∀ {k : Type u} {G : Type v} [inst : Ring k] [inst_1 : Monoid G] {A B : Rep.{w, u, v} k G} (f : A ⟶ B)
[CategoryTheory.Epi f], CategoryTheory.Epi (Rep.Hom.toModuleCatHom f) | null | true |
LaurentSeries.instFieldSpaceWithValRatFuncWithZeroMultiplicativeIntPolynomialValuationXRatfuncAdicComplPkg._proof_22 | Mathlib.RingTheory.LaurentSeries | ∀ {K : Type u_1} [inst : Field K],
autoParam (∀ (x : LaurentSeries.ratfuncAdicComplPkg.space), x ^ 0 = 1) Monoid.npow_zero._autoParam | null | false |
_private.Std.Data.ExtHashSet.Lemmas.0.Std.ExtHashSet.erase_eq_empty_iff._simp_1_1 | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m m' : Std.ExtHashSet α}, (m = m') = (m.inner = m'.inner) | null | false |
Module.End.invtSubmodule_inf_invtSubmodule_le_invtSubmodule_add | Mathlib.Algebra.Module.Submodule.Invariant | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(f g : Module.End R M), f.invtSubmodule ⊓ g.invtSubmodule ≤ (f + g).invtSubmodule | null | true |
_private.Mathlib.Analysis.InnerProductSpace.Projection.Minimal.0.norm_eq_iInf_iff_real_inner_le_zero.match_1_1 | Mathlib.Analysis.InnerProductSpace.Projection.Minimal | ∀ {F : Type u_1} [inst : NormedAddCommGroup F] {K : Set F} {u : F} (x : ℝ)
(motive : (x ∈ Set.range fun w => ‖u - ↑w‖) → Prop) (x_1 : x ∈ Set.range fun w => ‖u - ↑w‖),
(∀ (w : ↑K) (h : (fun w => ‖u - ↑w‖) w = x), motive ⋯) → motive x_1 | null | false |
AlgebraicGeometry.IsOpenImmersion.forgetCreatesPullbackOfLeft._proof_2 | Mathlib.AlgebraicGeometry.OpenImmersion | ∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X ⟶ Z) (g : Y ⟶ Z) [H : AlgebraicGeometry.IsOpenImmersion f],
AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion
(CategoryTheory.Limits.pullback.snd (AlgebraicGeometry.Scheme.Hom.toLRSHom f)
(AlgebraicGeometry.Scheme.Hom.toLRSHom g)) | null | false |
Representation.IntertwiningMap.snd_comp_inr | Mathlib.RepresentationTheory.Intertwining | ∀ {A : Type u_1} {G : Type u_2} {V : Type u_3} {W : Type u_4} [inst : Semiring A] [inst_1 : Monoid G]
[inst_2 : AddCommMonoid V] [inst_3 : AddCommMonoid W] [inst_4 : Module A V] [inst_5 : Module A W]
{ρ : Representation A G V} {σ : Representation A G W},
(Representation.IntertwiningMap.snd A ρ σ).comp (Representa... | null | true |
CategoryTheory.Bicategory.Strict.associator_eqToIso._autoParam | Mathlib.CategoryTheory.Bicategory.Strict.Basic | Lean.Syntax | null | false |
Multiset.sub_le_sub_right | Mathlib.Data.Multiset.AddSub | ∀ {α : Type u_1} [inst : DecidableEq α] {s t u : Multiset α}, s ≤ t → s - u ≤ t - u | null | true |
Function.fromTypes_nil_equiv_apply | Mathlib.Logic.Function.FromTypes | ∀ (τ : Type u) (a : Function.FromTypes ![] τ), (Function.fromTypes_nil_equiv τ) a = a | null | true |
_private.Mathlib.AlgebraicGeometry.Gluing.0.AlgebraicGeometry.Scheme.IsLocallyDirected.t_id._simp_1_3 | Mathlib.AlgebraicGeometry.Gluing | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : X ⟶ Z} {g : Y ⟶ Z},
(CategoryTheory.CategoryStruct.comp α.inv f = g) = (f = CategoryTheory.CategoryStruct.comp α.hom g) | null | false |
Std.instStreamSubarray._proof_2 | Init.Data.Stream | ∀ {α : Type u_1} (s : Subarray α), s.start < s.stop → s.start < s.array.size | null | false |
Std.DHashMap.Internal.Raw₀.get!_insertIfNew | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α]
[inst_2 : LawfulBEq α],
(↑m).WF →
∀ {k a : α} [inst_3 : Inhabited (β a)] {v : β k},
(m.insertIfNew k v).get! a = if h : (k == a) = true ∧ m.contains k = false then cast ⋯ v else m.get! a | null | true |
Aesop.PhaseSpec.casesOn | Aesop.Builder.Basic | {motive : Aesop.PhaseSpec → Sort u} →
(t : Aesop.PhaseSpec) →
((info : Aesop.SafeRuleInfo) → motive (Aesop.PhaseSpec.safe info)) →
((info : Aesop.NormRuleInfo) → motive (Aesop.PhaseSpec.norm info)) →
((info : Aesop.UnsafeRuleInfo) → motive (Aesop.PhaseSpec.unsafe info)) → motive t | null | false |
Mathlib.Tactic.BicategoryLike.Normalize.Result._sizeOf_1 | Mathlib.Tactic.CategoryTheory.Coherence.PureCoherence | Mathlib.Tactic.BicategoryLike.Normalize.Result → ℕ | null | false |
Set.toFinset_smul_set | Mathlib.Algebra.Group.Pointwise.Finset.Scalar | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] [inst_1 : SMul α β] (a : α) (s : Set β) [inst_2 : Fintype ↑s]
[inst_3 : Fintype ↑(a • s)], (a • s).toFinset = a • s.toFinset | null | true |
LinearEquiv.domMulActCongrRight._proof_2 | Mathlib.Algebra.Module.Equiv.Basic | ∀ {S : Type u_7} {R₁ : Type u_3} {R₁' : Type u_6} {R₂' : Type u_4} {M₁ : Type u_1} {M₁' : Type u_5} {M₂' : Type u_2}
[inst : Semiring R₁] [inst_1 : Semiring R₁'] [inst_2 : Semiring R₂'] [inst_3 : AddCommMonoid M₁]
[inst_4 : AddCommMonoid M₁'] [inst_5 : AddCommMonoid M₂'] [inst_6 : Module R₁ M₁] [inst_7 : Module R₁'... | null | false |
OrderIso.neg | Mathlib.Algebra.Order.Group.OrderIso | (α : Type u) → [inst : AddGroup α] → [inst_1 : LE α] → [AddLeftMono α] → [AddRightMono α] → α ≃o αᵒᵈ | `x ↦ -x` as an order-reversing equivalence. | true |
PreconnectedSpace.isPreconnected_univ | Mathlib.Topology.Connected.Basic | ∀ {α : Type u} {inst : TopologicalSpace α} [self : PreconnectedSpace α], IsPreconnected Set.univ | The universal set `Set.univ` in a preconnected space is a preconnected set. | true |
BinaryTree.traverse._f | Mathlib.Data.Tree.Basic | {m : Type u_1 → Type u_2} →
[Applicative m] →
{α : Type u_3} → {β : Type u_1} → (α → m β) → (x : BinaryTree α) → BinaryTree.below x → m (BinaryTree β) | null | false |
Matrix.submatrixEquivInvertible | Mathlib.LinearAlgebra.Matrix.NonsingularInverse | {m : Type u} →
{n : Type u'} →
{α : Type v} →
[inst : Fintype n] →
[inst_1 : DecidableEq n] →
[inst_2 : CommRing α] →
[inst_3 : Fintype m] →
[inst_4 : DecidableEq m] →
(A : Matrix m m α) → (e₁ e₂ : n ≃ m) → [Invertible A] → Invertible (A.submatrix ... | `A.submatrix e₁ e₂` is invertible if `A` is | true |
List.append_right_inj | Init.Data.List.Lemmas | ∀ {α : Type u_1} {t₁ t₂ : List α} (s : List α), s ++ t₁ = s ++ t₂ ↔ t₁ = t₂ | null | true |
_private.Mathlib.Data.Num.ZNum.0.castNum.match_1.eq_2 | Mathlib.Data.Num.ZNum | ∀ (motive : Num → Sort u_1) (p : PosNum) (h_1 : Unit → motive Num.zero) (h_2 : (p : PosNum) → motive (Num.pos p)),
(match Num.pos p with
| Num.zero => h_1 ()
| Num.pos p => h_2 p) =
h_2 p | null | true |
CategoryTheory.down_comp | Mathlib.CategoryTheory.Category.ULift | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : CategoryTheory.AsSmall C} (f : X ⟶ Y) (g : Y ⟶ Z),
(CategoryTheory.CategoryStruct.comp f g).down = CategoryTheory.CategoryStruct.comp f.down g.down | null | true |
_private.Mathlib.Topology.Algebra.Valued.NormedValued.0.Valued.toNormedField.setOfPred_mem_integer_eq_closedBall._simp_1_1 | Mathlib.Topology.Algebra.Valued.NormedValued | ∀ {R : Type u} {Γ₀ : Type v} [inst : Ring R] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] (v : Valuation R Γ₀) (r : R),
(r ∈ v.integer) = (v r ≤ 1) | null | false |
Std.Iterators.PostconditionT.operation_map | Init.Data.Iterators.PostconditionMonad | ∀ {m : Type w → Type w'} [inst : Functor m] {α β : Type w} {x : Std.Iterators.PostconditionT m α} {f : α → β},
(Std.Iterators.PostconditionT.map f x).operation = (fun a => ⟨f ↑a, ⋯⟩) <$> x.operation | null | true |
Set.Finite.nonempty_fintype | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} {s : Set α}, s.Finite → Nonempty (Fintype ↑s) | **Alias** of the forward direction of `Set.finite_def`. | true |
_private.Mathlib.Tactic.TermCongr.0.Mathlib.Tactic.TermCongr.congrHoleIndex | Mathlib.Tactic.TermCongr | Lean.Name | Key for congruence hole metadata.
For a `Nat` recording how old this congruence hole is, to prevent reprocessing them
if they leak into the local context. | true |
TopModuleCat.instHasLimitsOfShapeOfModuleCat | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | ∀ {R : Type u} [inst : Ring R] [inst_1 : TopologicalSpace R] {J : Type u_2}
[inst_2 : CategoryTheory.Category.{v_1, u_2} J] [CategoryTheory.Limits.HasLimitsOfShape J (ModuleCat R)],
CategoryTheory.Limits.HasLimitsOfShape J (TopModuleCat R) | null | true |
String.Pos.Raw.utf8GetAux._unsafe_rec | Init.Data.String.Basic | List Char → String.Pos.Raw → String.Pos.Raw → Char | null | false |
CategoryTheory.ShiftedHom.comp_add | Mathlib.CategoryTheory.Shift.ShiftedHom | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {M : Type u_4} [inst_1 : AddMonoid M]
[inst_2 : CategoryTheory.HasShift C M] {X Y Z : C} [inst_3 : CategoryTheory.Preadditive C]
[∀ (a : M), (CategoryTheory.shiftFunctor C a).Additive] {a b c : M} (α : CategoryTheory.ShiftedHom X Y a)
(β₁ β₂ : Categor... | null | true |
MulAction.selfEquivSigmaOrbits._proof_1 | Mathlib.GroupTheory.GroupAction.Defs | ∀ (G : Type u_2) (α : Type u_1) [inst : Group G] [inst_1 : MulAction G α] (x : MulAction.orbitRel.Quotient G α),
x.orbit = MulAction.orbit G (Quotient.out x) | null | false |
Void.nonemptyType | Init.System.ST | Type → NonemptyType | null | true |
MeasureTheory.addContent_accumulate | Mathlib.MeasureTheory.Measure.AddContent | ∀ {α : Type u_1} {C : Set (Set α)} {G : Type u_2} [inst : AddCommMonoid G] (m : MeasureTheory.AddContent G C),
MeasureTheory.IsSetRing C →
∀ {s : ℕ → Set α},
Pairwise (Function.onFun Disjoint s) →
(∀ (i : ℕ), s i ∈ C) → ∀ (n : ℕ), m (Set.accumulate s n) = ∑ i ∈ Finset.range (n + 1), m (s i) | null | true |
Real.tan_mul_cos | Mathlib.Analysis.Complex.Trigonometric | ∀ {x : ℝ}, Real.cos x ≠ 0 → Real.tan x * Real.cos x = Real.sin x | null | true |
toModuleCatFromModuleCatLinearEquiv._proof_8 | Mathlib.RingTheory.Morita.Matrix | ∀ (R : Type u_2) {ι : Type u_3} [inst : Ring R] [inst_1 : Fintype ι] [inst_2 : DecidableEq ι]
(M : ModuleCat (Matrix ι ι R)) (j : ι) (m : ↑M) (i : ι),
∃ y,
{ toFun := (↑(DistribSMul.toAddMonoidHom (↑M) (Matrix.single j j 1))).toFun, map_add' := ⋯, map_smul' := ⋯ } y =
Matrix.single j i 1 • m | null | false |
hasStrictDerivAt_exp_zero | Mathlib.Analysis.SpecialFunctions.Exponential | ∀ {𝕂 : Type u_1} [inst : RCLike 𝕂], HasStrictDerivAt NormedSpace.exp 1 0 | The exponential map in `𝕂 = ℝ` or `𝕂 = ℂ` has strict derivative `1` at zero. | true |
LinearOrderedCommMonoidWithZero.toDecidableEq._inherited_default | Mathlib.Algebra.Order.GroupWithZero.Canonical | {α : Type u_3} →
(le lt : α → α → Prop) →
(∀ (a : α), le a a) →
(∀ (a b c : α), le a b → le b c → le a c) →
(∀ (a b : α), lt a b ↔ le a b ∧ ¬le b a) →
(∀ (a b : α), le a b → le b a → a = b) → DecidableLE α → DecidableEq α | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.