tasksource/leandojo huggingface dataset:
Theorem: preimage_nhds_within_coinduced
File: Mathlib/Topology/ContinuousOn.lean

tactic: rw [← ht.nhdsWithin_eq h]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.12878
δ : Type ?u.12881
inst✝ : TopologicalSpace α
π : α → β
s : Set β
t : Set α
a : α
h : a ∈ t
ht : IsOpen t
hs : s ∈ 𝓝 (π a)
⊢ π ⁻¹' s ∈ 𝓝 a

tactic: exact preimage_nhdsWithin_coinduced' h hs
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.12878
δ : Type ?u.12881
inst✝ : TopologicalSpace α
π : α → β
s : Set β
t : Set α
a : α
h : a ∈ t
ht : IsOpen t
hs : s ∈ 𝓝 (π a)
⊢ π ⁻¹' s ∈ 𝓝[t] a
Theorem: Submodule.range_liftQ
File: Mathlib/LinearAlgebra/Quotient.lean

tactic: simpa only [range_eq_map] using map_liftQ _ _ _ _
state_before: R : Type u_1
M : Type u_3
r : R
x y : M
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
p p' : Submodule R M
R₂ : Type u_2
M₂ : Type u_4
inst✝³ : Ring R₂
inst✝² : AddCommGroup M₂
inst✝¹ : Module R₂ M₂
τ₁₂ : R →+* R₂
q : Submodule R₂ M₂
inst✝ : RingHomSurjective τ₁₂
f : M →ₛₗ[τ₁₂] M₂
h : p ≤ ker f
⊢ range (liftQ p f h) = range f
Theorem: bddBelow_bddAbove_iff_subset_Icc
File: Mathlib/Order/Bounds/Basic.lean

tactic: simp [Ici_inter_Iic.symm, subset_inter_iff, bddBelow_iff_subset_Ici,
  bddAbove_iff_subset_Iic, exists_and_left, exists_and_right]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : Preorder α
inst✝ : Preorder β
s t : Set α
a b : α
⊢ BddBelow s ∧ BddAbove s ↔ ∃ a b, s ⊆ Icc a b
Theorem: Nat.gcdA_zero_left
File: Mathlib/Data/Int/GCD.lean

tactic: unfold gcdA
state_before: s : ℕ
⊢ gcdA 0 s = 0

tactic: rw [xgcd, xgcd_zero_left]
state_before: s : ℕ
⊢ (xgcd 0 s).fst = 0
Theorem: CategoryTheory.Limits.limit_map_limitObjIsoLimitCompEvaluation_hom
File: Mathlib/CategoryTheory/Limits/FunctorCategory.lean

tactic: ext
state_before: C : Type u
inst✝⁴ : Category C
D : Type u'
inst✝³ : Category D
J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
inst✝ : HasLimitsOfShape J C
i j : K
F : J ⥤ K ⥤ C
f : i ⟶ j
⊢ (limit F).map f ≫ (limitObjIsoLimitCompEvaluation F j).hom =
    (limitObjIsoLimitCompEvaluation F i).hom ≫ limMap (whiskerLeft F ((evaluation K C).map f))

tactic: dsimp
state_before: case w
C : Type u
inst✝⁴ : Category C
D : Type u'
inst✝³ : Category D
J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
inst✝ : HasLimitsOfShape J C
i j : K
F : J ⥤ K ⥤ C
f : i ⟶ j
j✝ : J
⊢ ((limit F).map f ≫ (limitObjIsoLimitCompEvaluation F j).hom) ≫ limit.π (F ⋙ (evaluation K C).obj j) j✝ =
    ((limitObjIsoLimitCompEvaluation F i).hom ≫ limMap (whiskerLeft F ((evaluation K C).map f))) ≫
      limit.π (F ⋙ (evaluation K C).obj j) j✝

tactic: simp
state_before: case w
C : Type u
inst✝⁴ : Category C
D : Type u'
inst✝³ : Category D
J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
inst✝ : HasLimitsOfShape J C
i j : K
F : J ⥤ K ⥤ C
f : i ⟶ j
j✝ : J
⊢ ((limit F).map f ≫ (limitObjIsoLimitCompEvaluation F j).hom) ≫ limit.π (F ⋙ (evaluation K C).obj j) j✝ =
    ((limitObjIsoLimitCompEvaluation F i).hom ≫ limMap (whiskerLeft F ((evaluation K C).map f))) ≫
      limit.π (F ⋙ (evaluation K C).obj j) j✝
Theorem: Finset.Icc_diff_Ioo_self
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: simp [← coe_inj, h]
state_before: ι : Type ?u.100075
α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrder α
a b c : α
inst✝ : DecidableEq α
h : a ≤ b
⊢ Icc a b \ Ioo a b = {a, b}
Theorem: Algebraic.countable
File: Mathlib/Algebra/AlgebraicCard.lean

tactic: rw [← le_aleph0_iff_set_countable, ← lift_le]
state_before: R : Type u
A : Type v
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : IsDomain A
inst✝² : Algebra R A
inst✝¹ : NoZeroSMulDivisors R A
inst✝ : Countable R
⊢ Set.Countable {x | IsAlgebraic R x}

tactic: apply (cardinal_mk_lift_le_max R A).trans
state_before: R : Type u
A : Type v
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : IsDomain A
inst✝² : Algebra R A
inst✝¹ : NoZeroSMulDivisors R A
inst✝ : Countable R
⊢ lift (#↑{x | IsAlgebraic R x}) ≤ lift ℵ₀

tactic: simp
state_before: R : Type u
A : Type v
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : IsDomain A
inst✝² : Algebra R A
inst✝¹ : NoZeroSMulDivisors R A
inst✝ : Countable R
⊢ max (lift (#R)) ℵ₀ ≤ lift ℵ₀
Theorem: VectorFourier.norm_fourierIntegral_le_integral_norm
File: Mathlib/Analysis/Fourier/FourierTransform.lean

tactic: refine' (norm_integral_le_integral_norm _).trans (le_of_eq _)
state_before: 𝕜 : Type u_1
inst✝⁸ : CommRing 𝕜
V : Type u_2
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module 𝕜 V
inst✝⁵ : MeasurableSpace V
W : Type u_3
inst✝⁴ : AddCommGroup W
inst✝³ : Module 𝕜 W
E : Type u_4
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
e : Multiplicative 𝕜 →* { x // x ∈ 𝕊 }
μ : MeasureTheory.Measure V
L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜
f : V → E
w : W
⊢ ‖fourierIntegral e μ L f w‖ ≤ ∫ (v : V), ‖f v‖ ∂μ

tactic: simp_rw [norm_smul, Complex.norm_eq_abs, abs_coe_circle, one_mul]
state_before: 𝕜 : Type u_1
inst✝⁸ : CommRing 𝕜
V : Type u_2
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module 𝕜 V
inst✝⁵ : MeasurableSpace V
W : Type u_3
inst✝⁴ : AddCommGroup W
inst✝³ : Module 𝕜 W
E : Type u_4
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
e : Multiplicative 𝕜 →* { x // x ∈ 𝕊 }
μ : MeasureTheory.Measure V
L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜
f : V → E
w : W
⊢ (∫ (a : V), ‖↑(↑e (↑Multiplicative.ofAdd (-↑(↑L a) w))) • f a‖ ∂μ) = ∫ (v : V), ‖f v‖ ∂μ
Theorem: NNReal.rpow_add_rpow_le_add
File: Mathlib/Analysis/MeanInequalitiesPow.lean

tactic: rw [← @NNReal.le_rpow_one_div_iff _ _ (1 / p) (by simp [lt_of_lt_of_le zero_lt_one hp1])]
state_before: ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
⊢ (a ^ p + b ^ p) ^ (1 / p) ≤ a + b

tactic: rw [one_div_one_div]
state_before: ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
⊢ a ^ p + b ^ p ≤ (a + b) ^ (1 / (1 / p))

tactic: exact add_rpow_le_rpow_add _ _ hp1
state_before: ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
⊢ a ^ p + b ^ p ≤ (a + b) ^ p

tactic: simp [lt_of_lt_of_le zero_lt_one hp1]
state_before: ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
⊢ 0 < 1 / p
Theorem: PosNum.cast_lt
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [← cast_to_nat m, ← cast_to_nat n, Nat.cast_lt (α := α), lt_to_nat]
state_before: α : Type u_1
inst✝ : LinearOrderedSemiring α
m n : PosNum
⊢ ↑m < ↑n ↔ m < n
Theorem: Submodule.IsOrtho.comap_iff
File: Mathlib/Analysis/InnerProductSpace/Orthogonal.lean

tactic: have hf : ∀ p : Submodule 𝕜 F, (p.comap f).map f.toLinearIsometry = p :=
  map_comap_eq_of_surjective f.surjective
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
f : E ≃ₗᵢ[𝕜] F
U V : Submodule 𝕜 F
h : Submodule.comap f U ⟂ Submodule.comap f V
⊢ U ⟂ V

tactic: simpa only [hf] using h.map f.toLinearIsometry
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
f : E ≃ₗᵢ[𝕜] F
U V : Submodule 𝕜 F
h : Submodule.comap f U ⟂ Submodule.comap f V
hf : ∀ (p : Submodule 𝕜 F), Submodule.map (LinearIsometryEquiv.toLinearIsometry f) (Submodule.comap f p) = p
⊢ U ⟂ V
Theorem: BooleanRing.inf_assoc
File: Mathlib/Algebra/Ring/BooleanRing.lean

tactic: ring
state_before: α : Type u_1
β : Type ?u.13707
γ : Type ?u.13710
inst✝² : BooleanRing α
inst✝¹ : BooleanRing β
inst✝ : BooleanRing γ
a b c : α
⊢ a * b * c = a * (b * c)
Theorem: Submodule.map_comap_eq
File: Mathlib/LinearAlgebra/Basic.lean

tactic: rintro _ ⟨⟨x, _, rfl⟩, hx⟩
state_before: R : Type u_1
R₁ : Type ?u.1242999
R₂ : Type u_2
R₃ : Type ?u.1243005
R₄ : Type ?u.1243008
S : Type ?u.1243011
K : Type ?u.1243014
K₂ : Type ?u.1243017
M : Type u_4
M' : Type ?u.1243023
M₁ : Type ?u.1243026
M₂ : Type u_3
M₃ : Type ?u.1243032
M₄ : Type ?u.1243035
N : Type ?u.1243038
N₂ : Type ?u.1243041
ι : Type ?u.1243044
V : Type ?u.1243047
V₂ : Type ?u.1243050
inst✝¹¹ : Semiring R
inst✝¹⁰ : Semiring R₂
inst✝⁹ : Semiring R₃
inst✝⁸ : AddCommMonoid M
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : AddCommMonoid M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁵ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝⁴ : Module R M
inst✝³ : Module R₂ M₂
inst✝² : Module R₃ M₃
σ₂₁ : R₂ →+* R
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝¹ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
F : Type u_5
sc : SemilinearMapClass F τ₁₂ M M₂
inst✝ : RingHomSurjective τ₁₂
f : F
q : Submodule R₂ M₂
⊢ range f ⊓ q ≤ map f (comap f q)

tactic: exact ⟨x, hx, rfl⟩
state_before: case intro.intro.refl
R : Type u_1
R₁ : Type ?u.1242999
R₂ : Type u_2
R₃ : Type ?u.1243005
R₄ : Type ?u.1243008
S : Type ?u.1243011
K : Type ?u.1243014
K₂ : Type ?u.1243017
M : Type u_4
M' : Type ?u.1243023
M₁ : Type ?u.1243026
M₂ : Type u_3
M₃ : Type ?u.1243032
M₄ : Type ?u.1243035
N : Type ?u.1243038
N₂ : Type ?u.1243041
ι : Type ?u.1243044
V : Type ?u.1243047
V₂ : Type ?u.1243050
inst✝¹¹ : Semiring R
inst✝¹⁰ : Semiring R₂
inst✝⁹ : Semiring R₃
inst✝⁸ : AddCommMonoid M
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : AddCommMonoid M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁵ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝⁴ : Module R M
inst✝³ : Module R₂ M₂
inst✝² : Module R₃ M₃
σ₂₁ : R₂ →+* R
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝¹ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
F : Type u_5
sc : SemilinearMapClass F τ₁₂ M M₂
inst✝ : RingHomSurjective τ₁₂
f : F
q : Submodule R₂ M₂
x : M
hx : ↑f x ∈ ↑q
⊢ ↑f x ∈ map f (comap f q)
Theorem: linearIndependent_le_span'
File: Mathlib/LinearAlgebra/Dimension.lean

tactic: haveI : Fintype ι := linearIndependentFintypeOfLeSpanFintype v i w s
state_before: K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι✝ : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.349139
R : Type u
inst✝⁴ : Ring R
inst✝³ : StrongRankCondition R
M : Type v
inst✝² : AddCommGroup M
inst✝¹ : Module R M
ι : Type u_1
v : ι → M
i : LinearIndependent R v
w : Set M
inst✝ : Fintype ↑w
s : range v ≤ ↑(span R w)
⊢ (#ι) ≤ ↑(Fintype.card ↑w)

tactic: rw [Cardinal.mk_fintype]
state_before: K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι✝ : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.349139
R : Type u
inst✝⁴ : Ring R
inst✝³ : StrongRankCondition R
M : Type v
inst✝² : AddCommGroup M
inst✝¹ : Module R M
ι : Type u_1
v : ι → M
i : LinearIndependent R v
w : Set M
inst✝ : Fintype ↑w
s : range v ≤ ↑(span R w)
this : Fintype ι
⊢ (#ι) ≤ ↑(Fintype.card ↑w)

tactic: simp only [Cardinal.natCast_le]
state_before: K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι✝ : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.349139
R : Type u
inst✝⁴ : Ring R
inst✝³ : StrongRankCondition R
M : Type v
inst✝² : AddCommGroup M
inst✝¹ : Module R M
ι : Type u_1
v : ι → M
i : LinearIndependent R v
w : Set M
inst✝ : Fintype ↑w
s : range v ≤ ↑(span R w)
this : Fintype ι
⊢ ↑(Fintype.card ι) ≤ ↑(Fintype.card ↑w)

tactic: exact linearIndependent_le_span_aux' v i w s
state_before: K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι✝ : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.349139
R : Type u
inst✝⁴ : Ring R
inst✝³ : StrongRankCondition R
M : Type v
inst✝² : AddCommGroup M
inst✝¹ : Module R M
ι : Type u_1
v : ι → M
i : LinearIndependent R v
w : Set M
inst✝ : Fintype ↑w
s : range v ≤ ↑(span R w)
this : Fintype ι
⊢ Fintype.card ι ≤ Fintype.card ↑w
Theorem: HasDerivAtFilter.sub_const
File: Mathlib/Analysis/Calculus/Deriv/Add.lean

tactic: simpa only [sub_eq_add_neg] using hf.add_const (-c)
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
hf : HasDerivAtFilter f f' x L
c : F
⊢ HasDerivAtFilter (fun x => f x - c) f' x L
Theorem: List.cycleOf_formPerm
File: Mathlib/GroupTheory/Perm/Cycle/Concrete.lean

tactic: rwa [← length_attach] at hn
state_before: α : Type u_1
inst✝ : DecidableEq α
l l' : List α
hl : Nodup l
hn : 2 ≤ length l
x : { x // x ∈ l }
⊢ 2 ≤ length (attach l)

tactic: rwa [← nodup_attach] at hl
state_before: α : Type u_1
inst✝ : DecidableEq α
l l' : List α
hl : Nodup l
hn✝ : 2 ≤ length l
x : { x // x ∈ l }
hn : 2 ≤ length (attach l)
⊢ Nodup (attach l)
Theorem: Zspan.fract_eq_fract
File: Mathlib/Algebra/Module/Zlattice.lean

tactic: classical
rw [eq_comm, Basis.ext_elem_iff b]
simp_rw [repr_fract_apply, Int.fract_eq_fract, eq_comm, Basis.mem_span_iff_repr_mem,
  sub_eq_neg_add, map_add, LinearEquiv.map_neg, Finsupp.coe_add, Finsupp.coe_neg, Pi.add_apply,
  Pi.neg_apply, ← eq_intCast (algebraMap ℤ K) _, Set.mem_range]
state_before: E : Type u_1
ι : Type u_2
K : Type u_3
inst✝⁴ : NormedLinearOrderedField K
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace K E
b : Basis ι K E
inst✝¹ : FloorRing K
inst✝ : Fintype ι
m n : E
⊢ fract b m = fract b n ↔ -m + n ∈ span ℤ (Set.range ↑b)

tactic: rw [eq_comm, Basis.ext_elem_iff b]
state_before: E : Type u_1
ι : Type u_2
K : Type u_3
inst✝⁴ : NormedLinearOrderedField K
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace K E
b : Basis ι K E
inst✝¹ : FloorRing K
inst✝ : Fintype ι
m n : E
⊢ fract b m = fract b n ↔ -m + n ∈ span ℤ (Set.range ↑b)

tactic: simp_rw [repr_fract_apply, Int.fract_eq_fract, eq_comm, Basis.mem_span_iff_repr_mem,
  sub_eq_neg_add, map_add, LinearEquiv.map_neg, Finsupp.coe_add, Finsupp.coe_neg, Pi.add_apply,
  Pi.neg_apply, ← eq_intCast (algebraMap ℤ K) _, Set.mem_range]
state_before: E : Type u_1
ι : Type u_2
K : Type u_3
inst✝⁴ : NormedLinearOrderedField K
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace K E
b : Basis ι K E
inst✝¹ : FloorRing K
inst✝ : Fintype ι
m n : E
⊢ (∀ (i : ι), ↑(↑b.repr (fract b n)) i = ↑(↑b.repr (fract b m)) i) ↔ -m + n ∈ span ℤ (Set.range ↑b)
Theorem: FiniteDimensional.cardinal_mk_le_finrank_of_linearIndependent
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: rw [← lift_le.{_, max v w}]
state_before: K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
ι : Type w
b : ι → V
h : LinearIndependent K b
⊢ (#ι) ≤ ↑(finrank K V)

tactic: simpa [← finrank_eq_rank', -finrank_eq_rank] using
  cardinal_lift_le_rank_of_linearIndependent h
state_before: K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
ι : Type w
b : ι → V
h : LinearIndependent K b
⊢ lift (#ι) ≤ lift ↑(finrank K V)
Theorem: TopCat.Sheaf.pushforward_sheaf_of_sheaf
File: Mathlib/Topology/Sheaves/Functors.lean

tactic: rw [isSheaf_iff_isSheafPairwiseIntersections] at h ⊢
state_before: C : Type u
inst✝ : Category C
X Y : TopCat
f : X ⟶ Y
ι : Type w
U : ι → Opens ↑Y
F : Presheaf C X
h : Presheaf.IsSheaf F
⊢ Presheaf.IsSheaf (f _* F)

tactic: exact SheafConditionPairwiseIntersections.pushforward_sheaf_of_sheaf f h
state_before: C : Type u
inst✝ : Category C
X Y : TopCat
f : X ⟶ Y
ι : Type w
U : ι → Opens ↑Y
F : Presheaf C X
h : IsSheafPairwiseIntersections F
⊢ IsSheafPairwiseIntersections (f _* F)
Theorem: Monotone.image_upperBounds_subset_upperBounds_image
File: Mathlib/Order/Bounds/Basic.lean

tactic: rintro _ ⟨a, ha, rfl⟩
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
Hf : Monotone f
a : α
s : Set α
⊢ f '' upperBounds s ⊆ upperBounds (f '' s)

tactic: exact Hf.mem_upperBounds_image ha
state_before: case intro.intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
Hf : Monotone f
a✝ : α
s : Set α
a : α
ha : a ∈ upperBounds s
⊢ f a ∈ upperBounds (f '' s)
Theorem: Monotone.le_iterate_comp_of_le
File: Mathlib/Order/Iterate.lean

tactic: apply hf.seq_le_seq n <;> intros <;>
  simp [iterate_succ', -iterate_succ, comp_apply, id_eq, le_refl]
state_before: α : Type u_1
β : Type u_2
inst✝ : Preorder α
f : α → α
x✝ y : ℕ → α
g : β → β
h : β → α
hf : Monotone f
H : h ∘ g ≤ f ∘ h
n : ℕ
x : β
⊢ (h ∘ g^[n]) x ≤ (f^[n] ∘ h) x

tactic: case hx => exact H _
state_before: case hx
α : Type u_1
β : Type u_2
inst✝ : Preorder α
f : α → α
x✝ y : ℕ → α
g : β → β
h : β → α
hf : Monotone f
H : h ∘ g ≤ f ∘ h
n : ℕ
x : β
k✝ : ℕ
a✝ : k✝ < n
⊢ h (g ((g^[k✝]) x)) ≤ f (h ((g^[k✝]) x))

tactic: exact H _
state_before: α : Type u_1
β : Type u_2
inst✝ : Preorder α
f : α → α
x✝ y : ℕ → α
g : β → β
h : β → α
hf : Monotone f
H : h ∘ g ≤ f ∘ h
n : ℕ
x : β
k✝ : ℕ
a✝ : k✝ < n
⊢ h (g ((g^[k✝]) x)) ≤ f (h ((g^[k✝]) x))
Theorem: LipschitzWith.const
File: Mathlib/Topology/MetricSpace/Lipschitz.lean

tactic: simp only [edist_self, zero_le]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K : ℝ≥0
f : α → β
x✝ y✝ : α
r : ℝ≥0∞
b : β
x y : α
⊢ edist ((fun x => b) x) ((fun x => b) y) ≤ ↑0 * edist x y
Theorem: Nat.dvd_add_iff_left
File: Std/Data/Nat/Lemmas.lean

tactic: rw [Nat.add_comm]
state_before: k m n : Nat
h : k ∣ n
⊢ k ∣ m ↔ k ∣ m + n

tactic: exact Nat.dvd_add_iff_right h
state_before: k m n : Nat
h : k ∣ n
⊢ k ∣ m ↔ k ∣ n + m
Theorem: Multiset.strongInductionOn_eq
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [strongInductionOn]
state_before: α : Type u_1
β : Type ?u.74726
γ : Type ?u.74729
p : Multiset α → Sort u_2
s : Multiset α
H : (s : Multiset α) → ((t : Multiset α) → t < s → p t) → p s
⊢ strongInductionOn s H = H s fun t _h => strongInductionOn t H
Theorem: Int.ofNat_fmod
File: Std/Data/Int/DivMod.lean

tactic: cases m <;> simp [fmod]
state_before: m n : Nat
⊢ ↑(m % n) = fmod ↑m ↑n
Theorem: LieModule.iterate_toEndomorphism_mem_lowerCentralSeries
File: Mathlib/Algebra/Lie/Nilpotent.lean

tactic: induction' k with k ih
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N : LieSubmodule R L M
x : L
m : M
k : ℕ
⊢ (↑(↑(toEndomorphism R L M) x)^[k]) m ∈ lowerCentralSeries R L M k

tactic: simp only [Nat.zero_eq, Function.iterate_zero, lowerCentralSeries_zero, LieSubmodule.mem_top]
state_before: case zero
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k : ℕ
N : LieSubmodule R L M
x : L
m : M
⊢ (↑(↑(toEndomorphism R L M) x)^[Nat.zero]) m ∈ lowerCentralSeries R L M Nat.zero

tactic: simp only [lowerCentralSeries_succ, Function.comp_apply, Function.iterate_succ',
  toEndomorphism_apply_apply]
state_before: case succ
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N : LieSubmodule R L M
x : L
m : M
k : ℕ
ih : (↑(↑(toEndomorphism R L M) x)^[k]) m ∈ lowerCentralSeries R L M k
⊢ (↑(↑(toEndomorphism R L M) x)^[Nat.succ k]) m ∈ lowerCentralSeries R L M (Nat.succ k)

tactic: exact LieSubmodule.lie_mem_lie _ _ (LieSubmodule.mem_top x) ih
state_before: case succ
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N : LieSubmodule R L M
x : L
m : M
k : ℕ
ih : (↑(↑(toEndomorphism R L M) x)^[k]) m ∈ lowerCentralSeries R L M k
⊢ ⁅x, (↑(↑(toEndomorphism R L M) x)^[k]) m⁆ ∈ ⁅⊤, lowerCentralSeries R L M k⁆
Theorem: continuousOn_iff'
File: Mathlib/Topology/ContinuousOn.lean

tactic: rw [continuousOn_iff_continuous_restrict, continuous_def]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.313683
δ : Type ?u.313686
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
this : ∀ (t : Set β), IsOpen (restrict s f ⁻¹' t) ↔ ∃ u, IsOpen u ∧ f ⁻¹' t ∩ s = u ∩ s
⊢ ContinuousOn f s ↔ ∀ (t : Set β), IsOpen t → ∃ u, IsOpen u ∧ f ⁻¹' t ∩ s = u ∩ s

tactic: simp only [this]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.313683
δ : Type ?u.313686
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
this : ∀ (t : Set β), IsOpen (restrict s f ⁻¹' t) ↔ ∃ u, IsOpen u ∧ f ⁻¹' t ∩ s = u ∩ s
⊢ (∀ (s_1 : Set β), IsOpen s_1 → IsOpen (restrict s f ⁻¹' s_1)) ↔
    ∀ (t : Set β), IsOpen t → ∃ u, IsOpen u ∧ f ⁻¹' t ∩ s = u ∩ s

tactic: intro t
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.313683
δ : Type ?u.313686
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
⊢ ∀ (t : Set β), IsOpen (restrict s f ⁻¹' t) ↔ ∃ u, IsOpen u ∧ f ⁻¹' t ∩ s = u ∩ s

tactic: rw [isOpen_induced_iff, Set.restrict_eq, Set.preimage_comp]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.313683
δ : Type ?u.313686
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
t : Set β
⊢ IsOpen (restrict s f ⁻¹' t) ↔ ∃ u, IsOpen u ∧ f ⁻¹' t ∩ s = u ∩ s

tactic: simp only [Subtype.preimage_coe_eq_preimage_coe_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.313683
δ : Type ?u.313686
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
t : Set β
⊢ (∃ t_1, IsOpen t_1 ∧ Subtype.val ⁻¹' t_1 = Subtype.val ⁻¹' (f ⁻¹' t)) ↔ ∃ u, IsOpen u ∧ f ⁻¹' t ∩ s = u ∩ s

tactic: rintro ⟨u, ou, useq⟩
state_before: case mpr
α : Type u_1
β : Type u_2
γ : Type ?u.313683
δ : Type ?u.313686
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
t : Set β
⊢ (∃ u, IsOpen u ∧ f ⁻¹' t ∩ s = u ∩ s) → ∃ t_1, IsOpen t_1 ∧ t_1 ∩ s = f ⁻¹' t ∩ s

tactic: exact ⟨u, ou, useq.symm⟩
state_before: case mpr.intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.313683
δ : Type ?u.313686
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
t : Set β
u : Set α
ou : IsOpen u
useq : f ⁻¹' t ∩ s = u ∩ s
⊢ ∃ t_1, IsOpen t_1 ∧ t_1 ∩ s = f ⁻¹' t ∩ s
Theorem: isSimpleModule_iff_isCoatom
File: Mathlib/RingTheory/SimpleModule.lean

tactic: rw [← Set.isSimpleOrder_Ici_iff_isCoatom]
state_before: R : Type u_1
inst✝⁴ : Ring R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
m : Submodule R M
N : Type ?u.17852
inst✝¹ : AddCommGroup N
inst✝ : Module R N
⊢ IsSimpleModule R (M ⧸ m) ↔ IsCoatom m

tactic: apply OrderIso.isSimpleOrder_iff
state_before: R : Type u_1
inst✝⁴ : Ring R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
m : Submodule R M
N : Type ?u.17852
inst✝¹ : AddCommGroup N
inst✝ : Module R N
⊢ IsSimpleModule R (M ⧸ m) ↔ IsSimpleOrder ↑(Set.Ici m)

tactic: exact Submodule.comapMkQRelIso m
state_before: case f
R : Type u_1
inst✝⁴ : Ring R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
m : Submodule R M
N : Type ?u.17852
inst✝¹ : AddCommGroup N
inst✝ : Module R N
⊢ Submodule R (M ⧸ m) ≃o ↑(Set.Ici m)
Theorem: Mathlib.Meta.NormNum.isNat_natSucc
File: Mathlib/Tactic/NormNum/Basic.lean

tactic: simp
state_before: n✝ : ℕ
⊢ Nat.succ ↑n✝ = ↑(Nat.succ n✝)
Theorem: isLowerSet_iff_Iic_subset
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp [IsLowerSet, subset_def, @forall_swap (_ ∈ s)]
state_before: α : Type u_1
β : Type ?u.12567
γ : Type ?u.12570
ι : Sort ?u.12573
κ : ι → Sort ?u.12578
inst✝¹ : Preorder α
inst✝ : Preorder β
s : Set α
p : α → Prop
a : α
⊢ IsLowerSet s ↔ ∀ ⦃a : α⦄, a ∈ s → Iic a ⊆ s