name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.MorphismProperty.ext | Mathlib.CategoryTheory.MorphismProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.CategoryStruct.{v, u} C] (W W' : CategoryTheory.MorphismProperty C),
(∀ ⦃X Y : C⦄ (f : X ⟶ Y), W f ↔ W' f) → W = W' | null | true |
measurable_from_prod_countable_left' | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {m : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ}
[Countable β] {f : α × β → γ},
(∀ (y : β), Measurable fun x => f (x, y)) →
(∀ (y y' : β) (x : α), y' ∈ measurableAtom y → f (x, y') = f (x, y)) → Measurable f | See `measurable_from_prod_countable_left` for a version where we assume that singletons are
measurable instead of reasoning about `measurableAtom`. | true |
Mathlib.Tactic.ITauto.applyProof | Mathlib.Tactic.ITauto | Lean.MVarId → Lean.NameMap Lean.Expr → Mathlib.Tactic.ITauto.Proof → Lean.MetaM Unit | Once we have a proof object, we have to apply it to the goal. | true |
CategoryTheory.Limits.SingleObj.Types.sections.equivFixedPoints._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.SingleObj | ∀ {M : Type u_2} [inst : Monoid M] (J : CategoryTheory.Functor (CategoryTheory.SingleObj M) (Type u_1)),
Function.RightInverse (fun p => ⟨fun x => ↑p, ⋯⟩) fun s => ⟨↑s (CategoryTheory.SingleObj.star M), ⋯⟩ | null | false |
String.contains_bool_eq | Init.Data.String.Lemmas.Pattern.Find.Pred | ∀ {p : Char → Bool} {s : String}, s.contains p = s.toList.any p | null | true |
OrderDual.btw | Mathlib.Order.Circular | (α : Type u_1) → [h : Btw α] → Btw αᵒᵈ | null | true |
Aesop.RuleApplication.mk | Aesop.RuleTac.Basic | Array Aesop.Subgoal →
Lean.Meta.SavedState → Option (Array Aesop.Script.LazyStep) → Option Aesop.Percent → Aesop.RuleApplication | null | true |
Lean.Parser.withoutInfo | Lean.Parser.Basic | Lean.Parser.Parser → Lean.Parser.Parser | null | true |
mem_irreducibleComponent | Mathlib.Topology.Irreducible | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x : X}, x ∈ irreducibleComponent x | [Stacks Tag 004W](https://stacks.math.columbia.edu/tag/004W) ((4)) | true |
Besicovitch.SatelliteConfig.inter | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u_1} [inst : MetricSpace α] {N : ℕ} {τ : ℝ} (self : Besicovitch.SatelliteConfig α N τ),
∀ i < Fin.last N, dist (self.c i) (self.c (Fin.last N)) ≤ self.r i + self.r (Fin.last N) | null | true |
_private.Std.Sat.CNF.Basic.0.Std.Sat.CNF.VarMem_append._simp_1_2 | Std.Sat.CNF.Basic | ∀ {α : Type u_1} {a : α} {xs ys : Array α}, (a ∈ xs ++ ys) = (a ∈ xs ∨ a ∈ ys) | null | false |
CategoryTheory.ProjectiveResolution.π_f_succ | Mathlib.CategoryTheory.Preadditive.Projective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} (P : CategoryTheory.ProjectiveResolution Z) (n : ℕ),
P.π.f (n + 1) = 0 | null | true |
Algebra.Generators.CotangentSpace.compEquiv._proof_6 | Mathlib.RingTheory.Kaehler.JacobiZariski | ∀ {S : Type u_1} [inst : CommRing S] {T : Type u_3} [inst_1 : CommRing T] [inst_2 : Algebra S T] {ι : Type u_2}
(Q : Algebra.Generators S T ι), SMulCommClass Q.toExtension.Ring T T | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.get!_union_of_contains_eq_false_right._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
Finset.Ico_union_Ico' | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} [inst : LinearOrder α] [inst_1 : LocallyFiniteOrder α] {a b c d : α},
c ≤ b → a ≤ d → Finset.Ico a b ∪ Finset.Ico c d = Finset.Ico (min a c) (max b d) | This is a special case of `Ico_union_Ico` | true |
_private.Lean.PrettyPrinter.0.Lean.PrettyPrinter.ppConstNameWithInfos._sparseCasesOn_1 | Lean.PrettyPrinter | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Lean.Meta.Constructions.SparseCasesOn.0.Lean.Meta.mkSparseCasesOn._sparseCasesOn_1 | Lean.Meta.Constructions.SparseCasesOn | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
instCountableFreeGroup | Mathlib.SetTheory.Cardinal.Free | ∀ (α : Type u) [Countable α], Countable (FreeGroup α) | null | true |
PUnit.sub_eq | Mathlib.Algebra.Group.PUnit | ∀ (x y : PUnit.{u_1 + 1}), x - y = PUnit.unit | null | true |
Subgroup.FiniteIndex | Mathlib.GroupTheory.Index | {G : Type u_1} → [inst : Group G] → Subgroup G → Prop | Typeclass for finite index subgroups. | true |
CategoryTheory.Presieve.instHasPullbacksSingletonOfHasPullback | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : Y ⟶ X) (g : Z ⟶ X)
[CategoryTheory.Limits.HasPullback g f], (CategoryTheory.Presieve.singleton g).HasPullbacks f | null | true |
Nat.toArray_rcc_eq_singleton_iff | Init.Data.Range.Polymorphic.NatLemmas | ∀ {k m n : ℕ}, (m...=n).toArray = #[k] ↔ n = m ∧ m = k | null | true |
_private.Lean.Elab.BuiltinTerm.0.Lean.Elab.Term.elabEnsureExpectedType._regBuiltin.Lean.Elab.Term.elabEnsureExpectedType.declRange_3 | Lean.Elab.BuiltinTerm | IO Unit | null | false |
Lean.Parser.Tactic.tacticHave' | Init.Tactics | Lean.ParserDescr | Similar to `have`, but using `refine'` | true |
FirstOrder.Language.age.fg_substructure | Mathlib.ModelTheory.Fraisse | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {S : L.Substructure M},
S.FG → { α := ↥S, str := inferInstance } ∈ L.age M | null | true |
OpenAddSubgroup.coe_toOpens | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] {U : OpenAddSubgroup G}, ↑↑U = ↑U | null | true |
Lean.JsonRpc.MessageKind.notification.elim | Lean.Data.JsonRpc | {motive : Lean.JsonRpc.MessageKind → Sort u} →
(t : Lean.JsonRpc.MessageKind) → t.ctorIdx = 1 → motive Lean.JsonRpc.MessageKind.notification → motive t | null | false |
NonUnitalSubsemiringClass.toNonUnitalCommSemiring._proof_2 | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | ∀ {S : Type u_2} (s : S) {R : Type u_1} [inst : NonUnitalCommSemiring R] [inst_1 : SetLike S R]
[inst_2 : NonUnitalSubsemiringClass S R] (a b : ↥s), a * b = b * a | null | false |
Std.Tactic.BVDecide.BVPred.noConfusionType | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | Sort u → Std.Tactic.BVDecide.BVPred → Std.Tactic.BVDecide.BVPred → Sort u | null | false |
_private.Mathlib.CategoryTheory.Sites.Sieves.0.CategoryTheory.Presieve.functorPushforward_monotone.match_1_1 | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] {F : CategoryTheory.Functor C D} {X : C}
(x : CategoryTheory.Presieve X) (x_1 : D) (x_2 : x_1 ⟶ F.obj X)
(motive : CategoryTheory.Presieve.functorPushforward F x x_2 → Prop)
(x_3 : Categ... | null | false |
JoinedIn.mono | Mathlib.Topology.Connected.PathConnected | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X} {U V : Set X}, JoinedIn U x y → U ⊆ V → JoinedIn V x y | null | true |
Lean.Lsp.LeanFileProgressProcessingInfo.mk.inj | Lean.Data.Lsp.Extra | ∀ {range : Lean.Lsp.Range} {kind : Lean.Lsp.LeanFileProgressKind} {range_1 : Lean.Lsp.Range}
{kind_1 : Lean.Lsp.LeanFileProgressKind},
{ range := range, kind := kind } = { range := range_1, kind := kind_1 } → range = range_1 ∧ kind = kind_1 | null | true |
Function.Injective.completeBooleanAlgebra._proof_4 | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u_1} {β : Type u_2} [inst : Max α] [inst_1 : Min α] [inst_2 : LE α] [inst_3 : LT α] [inst_4 : Top α]
[inst_5 : Bot α] [inst_6 : Compl α] [inst_7 : HImp α] [inst_8 : SDiff α] [inst_9 : CompleteBooleanAlgebra β]
(f : α → β) (hf : Function.Injective f) (le : ∀ {x y : α}, f x ≤ f y ↔ x ≤ y) (lt : ∀ {x y : α... | null | false |
Std.Tactic.BVDecide.BVExpr.bitblast.mkFullAdderCarry._proof_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] (aig : Std.Sat.AIG α) (lhs rhs cin : aig.Ref)
(hsub : aig.decls.size ≤ (aig.mkXorCached { lhs := lhs, rhs := rhs }).aig.decls.size),
(aig.mkXorCached { lhs := lhs, rhs := rhs }).aig.decls.size ≤
((aig.mkXorCached { lhs := lhs, rhs := rhs }).aig.mkAndCach... | null | false |
Filter.mem_pi_of_mem | Mathlib.Order.Filter.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} (i : ι) {s : Set (α i)},
s ∈ f i → Function.eval i ⁻¹' s ∈ Filter.pi f | null | true |
_private.Mathlib.Analysis.InnerProductSpace.Projection.FiniteDimensional.0._aux_Mathlib_Analysis_InnerProductSpace_Projection_FiniteDimensional___unexpand_Inner_inner_1 | Mathlib.Analysis.InnerProductSpace.Projection.FiniteDimensional | Lean.PrettyPrinter.Unexpander | null | false |
CategoryTheory.ShortComplex.cyclesFunctor_obj | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasKernels C] [inst_3 : CategoryTheory.Limits.HasCokernels C]
(S : CategoryTheory.ShortComplex C), (CategoryTheory.ShortComplex.cyclesFunctor C).obj S = S.cycles | null | true |
SimpleGraph.Subgraph.instInfSet._proof_2 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} (s : Set G.Subgraph) {v w : V},
(∀ ⦃G' : G.Subgraph⦄, G' ∈ s → G'.Adj v w) ∧ G.Adj v w → v ∈ ⋂ i ∈ s, i.verts | null | false |
Condensed.lanPresheafNatIso | Mathlib.Condensed.Discrete.Colimit | {F : CategoryTheory.Functor Profiniteᵒᵖ (Type (u + 1))} →
((S : Profinite) → CategoryTheory.Limits.IsColimit (F.mapCocone S.asLimitCone.op)) → (Condensed.lanPresheaf F ≅ F) | `lanPresheafIso` is natural in `S`. | true |
String.Slice.pos!_eq_pos | Init.Data.String.Lemmas.Basic | ∀ {s : String.Slice} {p : String.Pos.Raw} (h : String.Pos.Raw.IsValidForSlice s p), s.pos! p = s.pos p h | null | true |
InverseSystem.pEquivOnLim._proof_2 | Mathlib.Order.DirectedInverseSystem | ∀ {ι : Type u_2} {F : ι → Type u_3} {X : ι → Type u_1} {i : ι} [inst : LinearOrder ι]
{f : ⦃i j : ι⦄ → i ≤ j → F j → F i} [inst_1 : SuccOrder ι]
{equivSucc : ⦃i : ι⦄ → ¬IsMax i → F (Order.succ i) ≃ F i × X i} [inst_2 : WellFoundedLT ι]
(hi : Order.IsSuccPrelimit i) (e : (j : ↑(Set.Iio i)) → InverseSystem.PEquivOn... | null | false |
_private.Mathlib.Algebra.Homology.CochainComplexOpposite.0.CochainComplex.homotopyUnop._proof_4 | Mathlib.Algebra.Homology.CochainComplexOpposite | ∀ (p p' : ℤ), p = p' → ComplexShape.embeddingUpIntDownInt.f p' = ComplexShape.embeddingUpIntDownInt.f p | null | false |
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme.0.AlgebraicGeometry.termSbo_ | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme | Lean.ParserDescr | basic open sets in `Spec` | true |
EReal.div_zero | Mathlib.Data.EReal.Inv | ∀ {a : EReal}, a / 0 = 0 | null | true |
Aesop.EMap.mk.sizeOf_spec | Aesop.EMap | ∀ {α : Type u_1} [inst : SizeOf α] (rep : Lean.PArray (Option (Lean.Expr × α))) (idx : Lean.Meta.DiscrTree ℕ),
sizeOf { rep := rep, idx := idx } = 1 + sizeOf rep + sizeOf idx | null | true |
LieModule.genWeightSpace_zero_normalizer_eq_self | Mathlib.Algebra.Lie.Weights.Basic | ∀ (R : Type u_2) (L : Type u_3) (M : Type u_4) [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]
[inst_7 : LieRing.IsNilpotent L], (LieModule.genWeightSpace M 0).normalizer = LieModule.genWeightS... | null | true |
ProbabilityTheory.indepSets_singleton_iff | Mathlib.Probability.Independence.Basic | ∀ {Ω : Type u_1} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {s t : Set Ω},
ProbabilityTheory.IndepSets {s} {t} μ ↔ μ (s ∩ t) = μ s * μ t | null | true |
Set.Pairwise.insert_of_symmetric | Mathlib.Data.Set.Pairwise.Basic | ∀ {α : Type u_1} {r : α → α → Prop} {s : Set α} {a : α} [Std.Symm r],
s.Pairwise r → (∀ b ∈ s, a ≠ b → r a b) → (insert a s).Pairwise r | **Alias** of `Set.Pairwise.insert_of_symm`. | true |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution.lambda_not_dvd_y | Mathlib.NumberTheory.FLT.Three | ∀ {K : Type u_1} [inst : Field K] {ζ : K} {hζ : IsPrimitiveRoot ζ 3} (S : FermatLastTheoremForThreeGen.Solution✝ hζ)
[inst_1 : NumberField K] [IsCyclotomicExtension {3} ℚ K],
¬hζ.toInteger - 1 ∣ FermatLastTheoremForThreeGen.Solution.y✝ S | null | true |
_private.Mathlib.Tactic.Tauto.0.Mathlib.Tactic.Tauto.distribNotAt.match_1 | Mathlib.Tactic.Tauto | (motive : ℕ → List Lean.Expr → Sort u_1) →
(nIters : ℕ) →
(x : List Lean.Expr) →
((x : List Lean.Expr) → motive 0 x) →
((x : ℕ) → motive x []) →
((n : ℕ) → (fv : Lean.Expr) → (fvs : List Lean.Expr) → motive n.succ (fv :: fvs)) → motive nIters x | null | false |
CategoryTheory.Localization.liftNatIso_hom | Mathlib.CategoryTheory.Localization.Predicate | ∀ {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] (L : CategoryTheory.Functor C D)
(W : CategoryTheory.MorphismProperty C) {E : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} E]
[inst_3 : L.IsLocalization W] (F₁ F₂ : CategoryTheor... | null | true |
isZGroup_iff_exists_mulEquiv | Mathlib.GroupTheory.SpecificGroups.ZGroup | ∀ {G : Type u_1} [inst : Group G] [Finite G],
IsZGroup G ↔ ∃ N H φ x, IsCyclic ↥H ∧ IsCyclic ↥N ∧ (Nat.card ↥N).Coprime (Nat.card ↥H) | A finite group `G` is a Z-group if and only if `G` is isomorphic to a semidirect product of two
cyclic subgroups of coprime order. | true |
Colex.exists._simp_1 | Mathlib.Order.Lex | ∀ {α : Type u_1} {p : Colex α → Prop}, (∃ a, p a) = ∃ a, p (toColex a) | null | false |
CategoryTheory.Limits.splitMonoOfIdempotentOfIsLimitFork_retraction | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] {X : C} {f : X ⟶ X}
(hf : CategoryTheory.CategoryStruct.comp f f = f)
{c : CategoryTheory.Limits.Fork (CategoryTheory.CategoryStruct.id X) f} (i : CategoryTheory.Limits.IsLimit c),
(CategoryTheory.Limits.splitMonoOfIdempotentOfIsLimitFork C hf i).retraction... | null | true |
MeasureTheory.AEEqFun.coeFn_add | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {α : Type u_1} {γ : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace γ]
[inst_2 : Add γ] [inst_3 : ContinuousAdd γ] (f g : α →ₘ[μ] γ), ↑(f + g) =ᵐ[μ] ↑f + ↑g | null | true |
Finset.noncommProd_mulSingle | Mathlib.Data.Finset.NoncommProd | ∀ {ι : Type u_2} {M : ι → Type u_6} [inst : (i : ι) → Monoid (M i)] [inst_1 : Fintype ι] [inst_2 : DecidableEq ι]
(x : (i : ι) → M i), Finset.univ.noncommProd (fun i => Pi.mulSingle i (x i)) ⋯ = x | null | true |
AlgebraicGeometry.Scheme.Modules.fromTildeΓNatTrans | Mathlib.AlgebraicGeometry.Modules.Tilde | {R : CommRingCat} →
AlgebraicGeometry.moduleSpecΓFunctor.comp (AlgebraicGeometry.tilde.functor R) ⟶
CategoryTheory.Functor.id (AlgebraicGeometry.Spec (CommRingCat.of ↑R)).Modules | This is the counit of the tilde-Gamma adjunction. | true |
Topology.IsQuotientMap.trivializationOfSMulDisjoint.match_7 | Mathlib.Topology.Covering.Quotient | ∀ {E : Type u_2} {X : Type u_1} {f : E → X} (U : Set E) (e : E) (motive : f e ∈ f '' U → Prop) (x : f e ∈ f '' U),
(∀ (e' : E) (he' : e' ∈ U) (hfe : f e' = f e), motive ⋯) → motive x | null | false |
derivWithin_intCast | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] (s : Set 𝕜) [inst_3 : IntCast F] (z : ℤ), derivWithin (↑z) s = 0 | null | true |
CategoryTheory.pi.coconeOfCoconeCompEval | Mathlib.CategoryTheory.Limits.Pi | {I : Type v₁} →
{C : I → Type u₁} →
[inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] →
{J : Type v₁} →
[inst_1 : CategoryTheory.SmallCategory J] →
{F : CategoryTheory.Functor J ((i : I) → C i)} →
((i : I) → CategoryTheory.Limits.Cocone (F.comp (CategoryTheory.Pi.eval C... | Given a family of cocones over the `F ⋙ Pi.eval C i`,
we can assemble these together as a `Cocone F`.
| true |
CategoryTheory.ShortComplex.ShortExact.fIsKernel._proof_1 | Mathlib.Algebra.Homology.ShortComplex.ShortExact | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{S : CategoryTheory.ShortComplex C}, S.ShortExact → CategoryTheory.Mono S.f | null | false |
ProofWidgets.LayoutKind.inline | ProofWidgets.Data.Html | ProofWidgets.LayoutKind | null | true |
Nat.getElem?_toArray_rio | Init.Data.Range.Polymorphic.NatLemmas | ∀ {n i : ℕ}, (*...n).toArray[i]? = if i < n then some i else none | null | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_210 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w w_1 : α)
(h_5 : 2 ≤ List.count w_1 [g a, g (g a)]),
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)])[List.idxOfNth w_1 [g a, g (g a)] 1] + 1 ≤
(List.filter (fun x => decide (x = w_1)) [g a, g (g a)]).length →
(List.findIdxs ... | null | false |
ContinuousLinearMap.flip_smul | Mathlib.Analysis.Normed.Operator.Bilinear | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {𝕜₃ : Type u_3} {E : Type u_4} {F : Type u_6} {G : Type u_8}
[inst : SeminormedAddCommGroup E] [inst_1 : SeminormedAddCommGroup F] [inst_2 : SeminormedAddCommGroup G]
[inst_3 : NontriviallyNormedField 𝕜] [inst_4 : NontriviallyNormedField 𝕜₂] [inst_5 : NontriviallyNormedField 𝕜... | null | true |
Batteries.PairingHeapImp.Heap.foldTreeM._f | Batteries.Data.PairingHeap | {m : Type u_1 → Type u_2} →
{β : Type u_1} →
{α : Type u_3} →
[Monad m] →
β → (α → β → β → m β) → (x : Batteries.PairingHeapImp.Heap α) → Batteries.PairingHeapImp.Heap.below x → m β | null | false |
AddSubgroup.Commensurable.discreteTopology_iff | Mathlib.Topology.Algebra.IsUniformGroup.DiscreteSubgroup | ∀ {G : Type u_2} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [IsTopologicalAddGroup G] [T2Space G]
{H K : AddSubgroup G}, H.Commensurable K → (DiscreteTopology ↥H ↔ DiscreteTopology ↥K) | null | true |
_private.Mathlib.Logic.Basic.0.exists_and_exists_comm.match_1_3 | Mathlib.Logic.Basic | ∀ {α : Sort u_1} {β : Sort u_2} {P : α → Prop} {Q : β → Prop} (motive : (∃ a b, P a ∧ Q b) → Prop)
(x : ∃ a b, P a ∧ Q b), (∀ (a : α) (b : β) (ha : P a) (hb : Q b), motive ⋯) → motive x | null | false |
IsPrimitiveRoot.neg_one | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {R : Type u_4} [inst : CommRing R] (p : ℕ) [Nontrivial R] [h : CharP R p], p ≠ 2 → IsPrimitiveRoot (-1) 2 | null | true |
ENat.card_prod | Mathlib.SetTheory.Cardinal.Finite | ∀ (α : Type u_3) (β : Type u_4), ENat.card (α × β) = ENat.card α * ENat.card β | null | true |
AddLocalization.liftOn.eq_1 | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {p : Sort u} (x : AddLocalization S) (f : M → ↥S → p)
(H : ∀ {a c : M} {b d : ↥S}, (AddLocalization.r S) (a, b) (c, d) → f a b = f c d),
x.liftOn f H = AddLocalization.rec f ⋯ x | null | true |
_private.Mathlib.Data.Set.Image.0.Set.disjoint_image_left._simp_1_1 | Mathlib.Data.Set.Image | ∀ {α : Type u} {s t : Set α}, Disjoint s t = (s ∩ t = ∅) | null | false |
lp.mapCLM | Mathlib.Analysis.Normed.Lp.lpHolder | {α : Type u_1} →
{𝕜 : Type u_2} →
{E : α → Type u_3} →
{F : α → Type u_4} →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : (i : α) → NormedAddCommGroup (E i)] →
[inst_2 : (i : α) → NormedSpace 𝕜 (E i)] →
[inst_3 : (i : α) → NormedAddCommGroup (F i)] →
... | A uniformly bounded family of continuous linear maps, as a continuous linear map
on the `lp` space. | true |
_private.Mathlib.Tactic.GCongr.Core.0.Lean.MVarId.gcongr.match_1 | Mathlib.Tactic.GCongr.Core | (motive : DoResultPR PUnit.{1} Bool PUnit.{1} → Sort u_1) →
(r : DoResultPR PUnit.{1} Bool PUnit.{1}) →
((a u : PUnit.{1}) → motive (DoResultPR.pure a u)) →
((b : Bool) → (u : PUnit.{1}) → motive (DoResultPR.return b u)) → motive r | null | false |
ModuleCat.forget₂AddCommGroup_reflectsLimitOfSize | Mathlib.Algebra.Category.ModuleCat.Limits | ∀ {R : Type u} [inst : Ring R],
CategoryTheory.Limits.ReflectsLimitsOfSize.{t, v, w, w, max u (w + 1), w + 1}
(CategoryTheory.forget₂ (ModuleCat R) AddCommGrpCat) | null | true |
ENNReal.instCommSemiring._proof_16 | Mathlib.Data.ENNReal.Basic | ∀ (a b : ENNReal), a * b = b * a | null | false |
smul_left_cancel_iff._simp_2 | Mathlib.Algebra.Group.Action.Basic | ∀ {α : Type u_5} {β : Type u_6} [inst : Group α] [inst_1 : MulAction α β] (g : α) {x y : β}, (g • x = g • y) = (x = y) | null | false |
Matrix.vecCons_inj._simp_1 | Mathlib.Data.Fin.VecNotation | ∀ {α : Type u} {n : ℕ} {x y : α} {u v : Fin n → α}, (Matrix.vecCons x u = Matrix.vecCons y v) = (x = y ∧ u = v) | null | false |
LinearMap.ofAEval._proof_6 | Mathlib.Algebra.Polynomial.Module.AEval | ∀ {R : Type u_3} {A : Type u_4} {M : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] (a : A)
[inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module A M] [inst_5 : Module R M]
[inst_6 : IsScalarTower R A M] {N : Type u_1} [inst_7 : AddCommMonoid N] [inst_8 : Module R N]
[inst_9 : Module (Polyno... | null | false |
Rat.sub | Init.Data.Rat.Basic | ℚ → ℚ → ℚ | Subtraction of rational numbers. (This definition is `@[irreducible]` because you don't want to
unfold it. Use `Rat.sub_def` instead.)
| true |
RBTree.RBNode.IsStrictCut.mk._flat_ctor | BatteriesRecycling.RBTree.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {cut : α → Ordering},
(∀ {x y : α} [Std.TransCmp cmp], cmp x y ≠ Ordering.gt → cut x = Ordering.lt → cut y = Ordering.lt) →
(∀ {x y : α} [Std.TransCmp cmp], cmp x y ≠ Ordering.gt → cut y = Ordering.gt → cut x = Ordering.gt) →
(∀ {x y : α} [Std.TransCmp cmp], cut x =... | null | false |
ContinuousLinearMapWOT.ext_dual_iff | Mathlib.Analysis.LocallyConvex.WeakOperatorTopology | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] {σ : 𝕜₁ →+* 𝕜₂} {E : Type u_3}
{F : Type u_4} [inst_2 : AddCommGroup E] [inst_3 : TopologicalSpace E] [inst_4 : Module 𝕜₁ E]
[inst_5 : AddCommGroup F] [inst_6 : TopologicalSpace F] [inst_7 : Module 𝕜₂ F] [H : SeparatingDual ... | null | true |
HopfAlgCat.MonoidalCategory.inducingFunctorData._proof_6 | Mathlib.Algebra.Category.HopfAlgCat.Monoidal | ∀ (R : Type u_1) [inst : CommRing R] (x : HopfAlgCat R),
(TensorProduct.mk R x.carrier (CategoryTheory.MonoidalCategoryStruct.tensorUnit (HopfAlgCat R)).carrier).compr₂ₛₗ
((fun x_1 => ↑x_1)
((CategoryTheory.forget₂ (HopfAlgCat R) (BialgCat R)).map
(CategoryTheory.MonoidalCategoryStruct.right... | null | false |
_private.Mathlib.RingTheory.TwoSidedIdeal.Operations.0.TwoSidedIdeal.mem_span_iff_mem_addSubgroup_closure_absorbing._simp_1_1 | Mathlib.RingTheory.TwoSidedIdeal.Operations | ∀ {R : Type u_1} [inst : NonUnitalNonAssocRing R] (carrier : Set R) (zero_mem : 0 ∈ carrier)
(add_mem : ∀ {x y : R}, x ∈ carrier → y ∈ carrier → x + y ∈ carrier) (neg_mem : ∀ {x : R}, x ∈ carrier → -x ∈ carrier)
(mul_mem_left : ∀ {x y : R}, y ∈ carrier → x * y ∈ carrier)
(mul_mem_right : ∀ {x y : R}, x ∈ carrier ... | null | false |
Turing.PartrecToTM2.move₂_ok | Mathlib.Computability.TuringMachine.ToPartrec | ∀ {p : Turing.PartrecToTM2.Γ' → Bool} {k₁ k₂ : Turing.PartrecToTM2.K'} {q : Turing.PartrecToTM2.Λ'}
{s : Option Turing.PartrecToTM2.Γ'} {L₁ : List Turing.PartrecToTM2.Γ'} {o : Option Turing.PartrecToTM2.Γ'}
{L₂ : List Turing.PartrecToTM2.Γ'} {S : Turing.PartrecToTM2.K' → List Turing.PartrecToTM2.Γ'},
k₁ ≠ Turing.... | null | true |
CategoryTheory.Limits.natTransIntoForgetCompFiberwiseColimit._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Grothendieck | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_3, u_5} C] {F : CategoryTheory.Functor C CategoryTheory.Cat}
{H : Type u_2} [inst_1 : CategoryTheory.Category.{u_1, u_2} H]
(G : CategoryTheory.Functor (CategoryTheory.Grothendieck F) H)
[inst_2 :
∀ {X Y : C} (f : X ⟶ Y),
CategoryTheory.Limits.HasColim... | null | false |
Lean.Elab.Tactic.RCases.RCasesPatt.noConfusion | Lean.Elab.Tactic.RCases | {P : Sort u} →
{t t' : Lean.Elab.Tactic.RCases.RCasesPatt} → t = t' → Lean.Elab.Tactic.RCases.RCasesPatt.noConfusionType P t t' | null | false |
Filter.HasBasis.cauchySeq_iff | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u} {β : Type v} [uniformSpace : UniformSpace α] {γ : Sort u_1} [Nonempty β] [inst : SemilatticeSup β]
{u : β → α} {p : γ → Prop} {s : γ → SetRel α α},
(uniformity α).HasBasis p s →
(CauchySeq u ↔ ∀ (i : γ), p i → ∃ N, ∀ (m : β), N ≤ m → ∀ (n : β), N ≤ n → (u m, u n) ∈ s i) | null | true |
CategoryTheory.BraidedCategory.Hexagon.functor₁₃₂ | Mathlib.CategoryTheory.Monoidal.Braided.Multifunctor | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[CategoryTheory.MonoidalCategory C] →
CategoryTheory.Functor C (CategoryTheory.Functor C (CategoryTheory.Functor C C)) | The trifunctor `X₁ X₂ X₃ ↦ (X₁ ⊗ X₃) ⊗ X₂` | true |
jacobiTheta₂.eq_1 | Mathlib.NumberTheory.ModularForms.JacobiTheta.TwoVariable | ∀ (z τ : ℂ), jacobiTheta₂ z τ = ∑' (n : ℤ), jacobiTheta₂_term n z τ | null | true |
TypeVec.toSubtype._unsafe_rec | Mathlib.Data.TypeVec | {n : ℕ} →
{α : TypeVec.{u} n} →
(p : α.Arrow (TypeVec.repeat n Prop)) →
TypeVec.Arrow (fun i => { x // TypeVec.ofRepeat (p i x) }) (TypeVec.Subtype_ p) | null | false |
Lean.Compiler.LCNF.Code.return.noConfusion | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
{P : Sort u} →
{fvarId fvarId' : Lean.FVarId} →
Lean.Compiler.LCNF.Code.return fvarId = Lean.Compiler.LCNF.Code.return fvarId' → (fvarId = fvarId' → P) → P | null | false |
PeriodPair.mem_lattice | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | ∀ {L : PeriodPair} {x : ℂ}, x ∈ L.lattice ↔ ∃ m n, ↑m * L.ω₁ + ↑n * L.ω₂ = x | null | true |
_private.Mathlib.SetTheory.ZFC.Rank.0.PSet.rank_insert._simp_1_2 | Mathlib.SetTheory.ZFC.Rank | ∀ {x y z : PSet.{u}}, (x ∈ insert y z) = (x.Equiv y ∨ x ∈ z) | null | false |
Lean.Lsp.RpcWireFormat.recOn | Lean.Server.Rpc.Basic | {motive : Lean.Lsp.RpcWireFormat → Sort u} →
(t : Lean.Lsp.RpcWireFormat) → motive Lean.Lsp.RpcWireFormat.v0 → motive Lean.Lsp.RpcWireFormat.v1 → motive t | null | false |
Std.Do._aux_Std_Do_PostCond___unexpand_Std_Do_PostCond_entails_1 | Std.Do.PostCond | Lean.PrettyPrinter.Unexpander | null | false |
Equiv.Perm.IsThreeCycle | Mathlib.GroupTheory.Perm.Cycle.Type | {α : Type u_1} → [Fintype α] → [DecidableEq α] → Equiv.Perm α → Prop | A three-cycle is a cycle of length 3. | true |
DFinsupp.Lex.acc_zero | Mathlib.Data.DFinsupp.WellFounded | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Zero (α i)] {r : ι → ι → Prop} {s : (i : ι) → α i → α i → Prop},
(∀ ⦃i : ι⦄ ⦃a : α i⦄, ¬s i a 0) → Acc (DFinsupp.Lex r s) 0 | null | true |
WittVector.idIsPolyI' | Mathlib.RingTheory.WittVector.IsPoly | ∀ (p : ℕ), WittVector.IsPoly p fun x x_1 a => a | null | true |
Prod.instTorsor.eq_1 | Mathlib.Algebra.Torsor.Basic | ∀ {G : Type u_1} {G' : Type u_2} {P : Type u_3} {P' : Type u_4} [inst : Group G] [inst_1 : Group G']
[inst_2 : Torsor G P] [inst_3 : Torsor G' P'],
Prod.instTorsor =
{ smul := fun v p => (v.1 • p.1, v.2 • p.2), mul_smul := ⋯, one_smul := ⋯,
sdiv := fun p₁ p₂ => (p₁.1 /ₛ p₂.1, p₁.2 /ₛ p₂.2), nonempty := ⋯,... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.