tasksource/leandojo huggingface dataset:
Theorem: continuous_thickenedIndicatorAux
File: Mathlib/Topology/MetricSpace/ThickenedIndicator.lean

tactic: unfold thickenedIndicatorAux
state_before: α : Type u_1
inst✝ : PseudoEMetricSpace α
δ : ℝ
δ_pos : 0 < δ
E : Set α
⊢ Continuous (thickenedIndicatorAux δ E)

tactic: let f := fun x : α => (⟨1, infEdist x E / ENNReal.ofReal δ⟩ : ℝ≥0 × ℝ≥0∞)
state_before: α : Type u_1
inst✝ : PseudoEMetricSpace α
δ : ℝ
δ_pos : 0 < δ
E : Set α
⊢ Continuous fun x => 1 - infEdist x E / ENNReal.ofReal δ

tactic: let sub := fun p : ℝ≥0 × ℝ≥0∞ => (p.1 : ℝ≥0∞) - p.2
state_before: α : Type u_1
inst✝ : PseudoEMetricSpace α
δ : ℝ
δ_pos : 0 < δ
E : Set α
f : α → ℝ≥0 × ℝ≥0∞ := fun x => (1, infEdist x E / ENNReal.ofReal δ)
⊢ Continuous fun x => 1 - infEdist x E / ENNReal.ofReal δ

tactic: rw [show (fun x : α => (1 : ℝ≥0∞) - infEdist x E / ENNReal.ofReal δ) = sub ∘ f by rfl]
state_before: α : Type u_1
inst✝ : PseudoEMetricSpace α
δ : ℝ
δ_pos : 0 < δ
E : Set α
f : α → ℝ≥0 × ℝ≥0∞ := fun x => (1, infEdist x E / ENNReal.ofReal δ)
sub : ℝ≥0 × ℝ≥0∞ → ℝ≥0∞ := fun p => ↑p.fst - p.snd
⊢ Continuous fun x => 1 - infEdist x E / ENNReal.ofReal δ

tactic: apply (@ENNReal.continuous_nnreal_sub 1).comp
state_before: α : Type u_1
inst✝ : PseudoEMetricSpace α
δ : ℝ
δ_pos : 0 < δ
E : Set α
f : α → ℝ≥0 × ℝ≥0∞ := fun x => (1, infEdist x E / ENNReal.ofReal δ)
sub : ℝ≥0 × ℝ≥0∞ → ℝ≥0∞ := fun p => ↑p.fst - p.snd
⊢ Continuous (sub ∘ f)

tactic: apply (ENNReal.continuous_div_const (ENNReal.ofReal δ) _).comp continuous_infEdist
state_before: α : Type u_1
inst✝ : PseudoEMetricSpace α
δ : ℝ
δ_pos : 0 < δ
E : Set α
f : α → ℝ≥0 × ℝ≥0∞ := fun x => (1, infEdist x E / ENNReal.ofReal δ)
sub : ℝ≥0 × ℝ≥0∞ → ℝ≥0∞ := fun p => ↑p.fst - p.snd
⊢ Continuous fun x => (f x).snd

tactic: norm_num
state_before: α : Type u_1
inst✝ : PseudoEMetricSpace α
δ : ℝ
δ_pos : 0 < δ
E : Set α
f : α → ℝ≥0 × ℝ≥0∞ := fun x => (1, infEdist x E / ENNReal.ofReal δ)
sub : ℝ≥0 × ℝ≥0∞ → ℝ≥0∞ := fun p => ↑p.fst - p.snd
⊢ ENNReal.ofReal δ ≠ 0

tactic: exact δ_pos
state_before: α : Type u_1
inst✝ : PseudoEMetricSpace α
δ : ℝ
δ_pos : 0 < δ
E : Set α
f : α → ℝ≥0 × ℝ≥0∞ := fun x => (1, infEdist x E / ENNReal.ofReal δ)
sub : ℝ≥0 × ℝ≥0∞ → ℝ≥0∞ := fun p => ↑p.fst - p.snd
⊢ 0 < δ

tactic: rfl
state_before: α : Type u_1
inst✝ : PseudoEMetricSpace α
δ : ℝ
δ_pos : 0 < δ
E : Set α
f : α → ℝ≥0 × ℝ≥0∞ := fun x => (1, infEdist x E / ENNReal.ofReal δ)
sub : ℝ≥0 × ℝ≥0∞ → ℝ≥0∞ := fun p => ↑p.fst - p.snd
⊢ (fun x => 1 - infEdist x E / ENNReal.ofReal δ) = sub ∘ f
Theorem: Real.sin_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: simpa [sq, mul_self_eq_one_iff] using sin_sq_add_cos_sq (π / 2)
state_before: ⊢ sin (π / 2) = 1 ∨ sin (π / 2) = -1

tactic: norm_num
state_before: this : sin (π / 2) = 1 ∨ sin (π / 2) = -1
h : sin (π / 2) = -1
⊢ ¬0 < -1
Theorem: AddCircle.norm_div_nat_cast
File: Mathlib/Analysis/Normed/Group/AddCircle.lean

tactic: have : p⁻¹ * (↑m / ↑n * p) = ↑m / ↑n := by rw [mul_comm _ p, inv_mul_cancel_left₀ hp.out.ne.symm]
state_before: p : ℝ
hp : Fact (0 < p)
m n : ℕ
⊢ ‖↑(↑m / ↑n * p)‖ = p * (↑(min (m % n) (n - m % n)) / ↑n)

tactic: rw [norm_eq' p hp.out, this, abs_sub_round_div_natCast_eq]
state_before: p : ℝ
hp : Fact (0 < p)
m n : ℕ
this : p⁻¹ * (↑m / ↑n * p) = ↑m / ↑n
⊢ ‖↑(↑m / ↑n * p)‖ = p * (↑(min (m % n) (n - m % n)) / ↑n)

tactic: rw [mul_comm _ p, inv_mul_cancel_left₀ hp.out.ne.symm]
state_before: p : ℝ
hp : Fact (0 < p)
m n : ℕ
⊢ p⁻¹ * (↑m / ↑n * p) = ↑m / ↑n
Theorem: MeasureTheory.L1.SimpleFunc.norm_eq_integral
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: rw [norm_eq_sum_mul f, (toSimpleFunc f).map_integral norm (SimpleFunc.integrable f) norm_zero]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.218028
𝕜 : Type ?u.218031
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
f : { x // x ∈ simpleFunc E 1 μ }
⊢ ‖f‖ = SimpleFunc.integral μ (SimpleFunc.map norm (toSimpleFunc f))

tactic: simp_rw [smul_eq_mul]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.218028
𝕜 : Type ?u.218031
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
f : { x // x ∈ simpleFunc E 1 μ }
⊢ ∑ x in SimpleFunc.range (toSimpleFunc f), ENNReal.toReal (↑↑μ (↑(toSimpleFunc f) ⁻¹' {x})) * ‖x‖ =
    ∑ x in SimpleFunc.range (toSimpleFunc f), ENNReal.toReal (↑↑μ (↑(toSimpleFunc f) ⁻¹' {x})) • ‖x‖
Theorem: Cardinal.mk_eq_two_iff
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: simp only [← @Nat.cast_two Cardinal, mk_eq_nat_iff_finset, Finset.card_eq_two]
state_before: α β : Type u
⊢ (#α) = 2 ↔ ∃ x y, x ≠ y ∧ {x, y} = univ

tactic: constructor
state_before: α β : Type u
⊢ (∃ t, ↑t = univ ∧ ∃ x y, x ≠ y ∧ t = {x, y}) ↔ ∃ x y, x ≠ y ∧ {x, y} = univ

tactic: rintro ⟨t, ht, x, y, hne, rfl⟩
state_before: case mp
α β : Type u
⊢ (∃ t, ↑t = univ ∧ ∃ x y, x ≠ y ∧ t = {x, y}) → ∃ x y, x ≠ y ∧ {x, y} = univ

tactic: exact ⟨x, y, hne, by simpa using ht⟩
state_before: case mp.intro.intro.intro.intro.intro
α β : Type u
x y : α
hne : x ≠ y
ht : ↑{x, y} = univ
⊢ ∃ x y, x ≠ y ∧ {x, y} = univ

tactic: simpa using ht
state_before: α β : Type u
x y : α
hne : x ≠ y
ht : ↑{x, y} = univ
⊢ {x, y} = univ

tactic: rintro ⟨x, y, hne, h⟩
state_before: case mpr
α β : Type u
⊢ (∃ x y, x ≠ y ∧ {x, y} = univ) → ∃ t, ↑t = univ ∧ ∃ x y, x ≠ y ∧ t = {x, y}

tactic: exact ⟨{x, y}, by simpa using h, x, y, hne, rfl⟩
state_before: case mpr.intro.intro.intro
α β : Type u
x y : α
hne : x ≠ y
h : {x, y} = univ
⊢ ∃ t, ↑t = univ ∧ ∃ x y, x ≠ y ∧ t = {x, y}

tactic: simpa using h
state_before: α β : Type u
x y : α
hne : x ≠ y
h : {x, y} = univ
⊢ ↑{x, y} = univ
Theorem: Continuous.min
File: Mathlib/Topology/Order/Basic.lean

tactic: simp only [min_def]
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderClosedTopology α
f g : β → α
inst✝ : TopologicalSpace β
hf : Continuous f
hg : Continuous g
⊢ Continuous fun b => min (f b) (g b)

tactic: exact hf.if_le hg hf hg fun x => id
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderClosedTopology α
f g : β → α
inst✝ : TopologicalSpace β
hf : Continuous f
hg : Continuous g
⊢ Continuous fun b => if f b ≤ g b then f b else g b
Theorem: Finmap.keys_erase
File: Mathlib/Data/Finmap.lean

tactic: simp
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
s✝ : Finmap β
s : AList β
⊢ keys (erase a ⟦s⟧) = Finset.erase (keys ⟦s⟧) a
Theorem: CategoryTheory.Abelian.mono_inr_of_isColimit
File: Mathlib/CategoryTheory/Abelian/Basic.lean

tactic: haveI : Mono (NatTrans.app (colimit.cocone (span f g)).ι WalkingCospan.right) :=
  Abelian.mono_pushout_of_mono_f f g
state_before: C : Type u
inst✝³ : Category C
inst✝² : Abelian C
inst✝¹ : HasPushouts C
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : Mono f
s : PushoutCocone f g
hs : IsColimit s
⊢ Mono (PushoutCocone.inr s)

tactic: apply
  mono_of_mono_fac (IsColimit.comp_coconePointUniqueUpToIso_hom hs (colimit.isColimit _) _)
state_before: C : Type u
inst✝³ : Category C
inst✝² : Abelian C
inst✝¹ : HasPushouts C
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : Mono f
s : PushoutCocone f g
hs : IsColimit s
this : Mono ((colimit.cocone (span f g)).ι.app WalkingCospan.right)
⊢ Mono (PushoutCocone.inr s)
Theorem: isClosed_separationRel
File: Mathlib/Topology/UniformSpace/Separation.lean

tactic: rw [separationRel_eq_inter_closure]
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
⊢ IsClosed (𝓢 α)

tactic: apply isClosed_sInter
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
⊢ IsClosed (⋂₀ (closure '' (𝓤 α).sets))

tactic: rintro _ ⟨t, -, rfl⟩
state_before: case a
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
⊢ ∀ (t : Set (α × α)), t ∈ closure '' (𝓤 α).sets → IsClosed t

tactic: exact isClosed_closure
state_before: case a.intro.intro
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
t : Set (α × α)
⊢ IsClosed (closure t)
Theorem: MeasureTheory.SimpleFunc.restrict_apply
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: simp only [f.coe_restrict hs]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.812591
δ : Type ?u.812594
inst✝¹ : MeasurableSpace α
K : Type ?u.812600
inst✝ : Zero β
f : α →ₛ β
s : Set α
hs : MeasurableSet s
a : α
⊢ ↑(restrict f s) a = indicator s (↑f) a
Theorem: Polynomial.card_support_eq_three
File: Mathlib/Data/Polynomial/EraseLead.lean

tactic: refine' ⟨fun h => _, _⟩
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
⊢ card (support f) = 3 ↔ ∃ k m n hkm hmn x y z hx hy hz, f = ↑C x * X ^ k + ↑C y * X ^ m + ↑C z * X ^ n

tactic: obtain ⟨k, x, hk, hx, rfl⟩ := card_support_eq.mp h
state_before: case refine'_1
R : Type u_1
inst✝ : Semiring R
f : R[X]
h : card (support f) = 3
⊢ ∃ k m n hkm hmn x y z hx hy hz, f = ↑C x * X ^ k + ↑C y * X ^ m + ↑C z * X ^ n

tactic: refine'
  ⟨k 0, k 1, k 2, hk Nat.zero_lt_one, hk (Nat.lt_succ_self 1), x 0, x 1, x 2, hx 0, hx 1, hx 2,
    _⟩
state_before: case refine'_1.intro.intro.intro.intro
R : Type u_1
inst✝ : Semiring R
k : Fin 3 → ℕ
x : Fin 3 → R
hk : StrictMono k
hx : ∀ (i : Fin 3), x i ≠ 0
h : card (support (∑ i : Fin 3, ↑C (x i) * X ^ k i)) = 3
⊢ ∃ k_1 m n hkm hmn x_1 y z hx hy hz, ∑ i : Fin 3, ↑C (x i) * X ^ k i = ↑C x_1 * X ^ k_1 + ↑C y * X ^ m + ↑C z * X ^ n

tactic: rw [Fin.sum_univ_castSucc, Fin.sum_univ_castSucc, Fin.sum_univ_one]
state_before: case refine'_1.intro.intro.intro.intro
R : Type u_1
inst✝ : Semiring R
k : Fin 3 → ℕ
x : Fin 3 → R
hk : StrictMono k
hx : ∀ (i : Fin 3), x i ≠ 0
h : card (support (∑ i : Fin 3, ↑C (x i) * X ^ k i)) = 3
⊢ ∑ i : Fin 3, ↑C (x i) * X ^ k i = ↑C (x 0) * X ^ k 0 + ↑C (x 1) * X ^ k 1 + ↑C (x 2) * X ^ k 2

tactic: rfl
state_before: case refine'_1.intro.intro.intro.intro
R : Type u_1
inst✝ : Semiring R
k : Fin 3 → ℕ
x : Fin 3 → R
hk : StrictMono k
hx : ∀ (i : Fin 3), x i ≠ 0
h : card (support (∑ i : Fin 3, ↑C (x i) * X ^ k i)) = 3
⊢ ↑C (x (↑Fin.castSucc (↑Fin.castSucc 0))) * X ^ k (↑Fin.castSucc (↑Fin.castSucc 0)) +
        ↑C (x (↑Fin.castSucc (Fin.last 1))) * X ^ k (↑Fin.castSucc (Fin.last 1)) +
      ↑C (x (Fin.last 2)) * X ^ k (Fin.last 2) =
    ↑C (x 0) * X ^ k 0 + ↑C (x 1) * X ^ k 1 + ↑C (x 2) * X ^ k 2

tactic: rintro ⟨k, m, n, hkm, hmn, x, y, z, hx, hy, hz, rfl⟩
state_before: case refine'_2
R : Type u_1
inst✝ : Semiring R
f : R[X]
⊢ (∃ k m n hkm hmn x y z hx hy hz, f = ↑C x * X ^ k + ↑C y * X ^ m + ↑C z * X ^ n) → card (support f) = 3

tactic: exact card_support_trinomial hkm hmn hx hy hz
state_before: case refine'_2.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
R : Type u_1
inst✝ : Semiring R
k m n : ℕ
hkm : k < m
hmn : m < n
x y z : R
hx : x ≠ 0
hy : y ≠ 0
hz : z ≠ 0
⊢ card (support (↑C x * X ^ k + ↑C y * X ^ m + ↑C z * X ^ n)) = 3
Theorem: Int.cast_bit1
File: Mathlib/Data/Int/Cast/Basic.lean

tactic: rw [bit1, Int.cast_add, Int.cast_one, cast_bit0]
state_before: R : Type u
inst✝ : AddGroupWithOne R
n : ℤ
⊢ ↑(bit1 n) = bit1 ↑n

tactic: rfl
state_before: R : Type u
inst✝ : AddGroupWithOne R
n : ℤ
⊢ bit0 ↑n + 1 = bit1 ↑n
Theorem: Filter.tendsto_comp_val_Ici_atTop
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: rw [← map_val_Ici_atTop a, tendsto_map'_iff]
state_before: ι : Type ?u.339440
ι' : Type ?u.339443
α : Type u_1
β : Type u_2
γ : Type ?u.339452
inst✝ : SemilatticeSup α
a : α
f : α → β
l : Filter β
⊢ Tendsto (fun x => f ↑x) atTop l ↔ Tendsto f atTop l

tactic: rfl
state_before: ι : Type ?u.339440
ι' : Type ?u.339443
α : Type u_1
β : Type u_2
γ : Type ?u.339452
inst✝ : SemilatticeSup α
a : α
f : α → β
l : Filter β
⊢ Tendsto (fun x => f ↑x) atTop l ↔ Tendsto (f ∘ Subtype.val) atTop l
Theorem: Set.iUnion_univ_pi
File: Mathlib/Data/Set/Lattice.lean

tactic: ext
state_before: α : Type u_2
β : Type ?u.288374
γ : Type ?u.288377
ι : Sort u_3
ι' : Sort ?u.288383
ι₂ : Sort ?u.288386
κ : ι → Sort ?u.288391
κ₁ : ι → Sort ?u.288396
κ₂ : ι → Sort ?u.288401
κ' : ι' → Sort ?u.288406
π : α → Type u_1
t : (i : α) → ι → Set (π i)
⊢ (⋃ (x : α → ι), pi univ fun i => t i (x i)) = pi univ fun i => ⋃ (j : ι), t i j

tactic: simp [Classical.skolem]
state_before: case h
α : Type u_2
β : Type ?u.288374
γ : Type ?u.288377
ι : Sort u_3
ι' : Sort ?u.288383
ι₂ : Sort ?u.288386
κ : ι → Sort ?u.288391
κ₁ : ι → Sort ?u.288396
κ₂ : ι → Sort ?u.288401
κ' : ι' → Sort ?u.288406
π : α → Type u_1
t : (i : α) → ι → Set (π i)
x✝ : (i : α) → π i
⊢ (x✝ ∈ ⋃ (x : α → ι), pi univ fun i => t i (x i)) ↔ x✝ ∈ pi univ fun i => ⋃ (j : ι), t i j
Theorem: Nat.lxor'_left_injective
File: Mathlib/Data/Nat/Bitwise.lean

tactic: rw [← lxor_cancel_right n m, ← lxor_cancel_right n m', h]
state_before: n m m' : ℕ
h : lxor' m n = lxor' m' n
⊢ m = m'
Theorem: Metric.sphere_union_ball
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: rw [union_comm, ball_union_sphere]
state_before: α : Type u
β : Type v
X : Type ?u.37673
ι : Type ?u.37676
inst✝ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
⊢ sphere x ε ∪ ball x ε = closedBall x ε
Theorem: List.remove_eq_of_not_mem
File: Mathlib/Data/List/Card.lean

tactic: simp [remove]
state_before: α : Type u_1
β : Sort ?u.19160
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a : α
x✝ : ¬a ∈ []
⊢ remove a [] = []

tactic: have h1 : a ≠ a' := fun h' ↦ h (by rw [h']; apply mem_cons_self)
state_before: α : Type u_1
β : Sort ?u.19160
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a a' : α
as : List α
h : ¬a ∈ a' :: as
⊢ remove a (a' :: as) = a' :: as

tactic: have h2 : a ∉ as := fun h' ↦ h (mem_cons_of_mem _ h')
state_before: α : Type u_1
β : Sort ?u.19160
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a a' : α
as : List α
h : ¬a ∈ a' :: as
h1 : a ≠ a'
⊢ remove a (a' :: as) = a' :: as

tactic: simp [remove, h1, remove_eq_of_not_mem h2]
state_before: α : Type u_1
β : Sort ?u.19160
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a a' : α
as : List α
h : ¬a ∈ a' :: as
h1 : a ≠ a'
h2 : ¬a ∈ as
⊢ remove a (a' :: as) = a' :: as

tactic: rw [h']
state_before: α : Type u_1
β : Sort ?u.19160
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a a' : α
as : List α
h : ¬a ∈ a' :: as
h' : a = a'
⊢ a ∈ a' :: as

tactic: apply mem_cons_self
state_before: α : Type u_1
β : Sort ?u.19160
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a a' : α
as : List α
h : ¬a ∈ a' :: as
h' : a = a'
⊢ a' ∈ a' :: as
Theorem: integrableOn_Ico_iff_integrableOn_Ioo'
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

tactic: by_cases hab : a < b
state_before: α : Type u_1
β : Type ?u.3301315
E : Type u_2
F : Type ?u.3301321
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : PartialOrder α
inst✝ : MeasurableSingletonClass α
f : α → E
μ : MeasureTheory.Measure α
a b : α
ha : ↑↑μ {a} ≠ ⊤
⊢ IntegrableOn f (Ico a b) ↔ IntegrableOn f (Ioo a b)

tactic: rw [← Ioo_union_left hab, integrableOn_union,
  eq_true (integrableOn_singleton_iff.mpr <| Or.inr ha.lt_top), and_true_iff]
state_before: case pos
α : Type u_1
β : Type ?u.3301315
E : Type u_2
F : Type ?u.3301321
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : PartialOrder α
inst✝ : MeasurableSingletonClass α
f : α → E
μ : MeasureTheory.Measure α
a b : α
ha : ↑↑μ {a} ≠ ⊤
hab : a < b
⊢ IntegrableOn f (Ico a b) ↔ IntegrableOn f (Ioo a b)

tactic: rw [Ioo_eq_empty hab, Ico_eq_empty hab]
state_before: case neg
α : Type u_1
β : Type ?u.3301315
E : Type u_2
F : Type ?u.3301321
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : PartialOrder α
inst✝ : MeasurableSingletonClass α
f : α → E
μ : MeasureTheory.Measure α
a b : α
ha : ↑↑μ {a} ≠ ⊤
hab : ¬a < b
⊢ IntegrableOn f (Ico a b) ↔ IntegrableOn f (Ioo a b)
Theorem: CompositionAsSet.toComposition_length
File: Mathlib/Combinatorics/Composition.lean

tactic: simp [CompositionAsSet.toComposition, Composition.length, Composition.blocks]
state_before: n : ℕ
c : CompositionAsSet n
⊢ Composition.length (toComposition c) = length c
Theorem: lt_inv'
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [← inv_lt_inv_iff, inv_inv]
state_before: α : Type u
inst✝³ : Group α
inst✝² : LT α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c d : α
⊢ a < b⁻¹ ↔ b < a⁻¹
Theorem: Nat.choose_le_centralBinom
File: Mathlib/Data/Nat/Choose/Central.lean

tactic: rw [Nat.mul_div_cancel_left n zero_lt_two]
state_before: r n : ℕ
⊢ choose (2 * n) (2 * n / 2) = choose (2 * n) n
Theorem: GaloisConnection.bddAbove_l_image
File: Mathlib/Order/GaloisConnection.lean

tactic: rwa [gc.upperBounds_l_image] at hx
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
κ : ι → Sort ?u.8887
a a₁ a₂ : α
b b₁ b₂ : β
inst✝¹ : Preorder α
inst✝ : Preorder β
l : α → β
u : β → α
gc : GaloisConnection l u
s : Set α
x✝ : BddAbove (l '' s)
x : β
hx : x ∈ upperBounds (l '' s)
⊢ u x ∈ upperBounds s
Theorem: TensorProduct.LieModule.coe_liftLie_eq_lift_coe
File: Mathlib/Algebra/Lie/TensorProduct.lean

tactic: suffices (liftLie R L M N P f : M ⊗[R] N →ₗ[R] P) = lift R L M N P f by
  rw [← this, LieModuleHom.coe_toLinearMap]
state_before: R : Type u
inst✝¹⁸ : CommRing R
L : Type v
M : Type w
N : Type w₁
P : Type w₂
Q : Type w₃
inst✝¹⁷ : LieRing L
inst✝¹⁶ : LieAlgebra R L
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
inst✝¹¹ : AddCommGroup N
inst✝¹⁰ : Module R N
inst✝⁹ : LieRingModule L N
inst✝⁸ : LieModule R L N
inst✝⁷ : AddCommGroup P
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L P
inst✝⁴ : LieModule R L P
inst✝³ : AddCommGroup Q
inst✝² : Module R Q
inst✝¹ : LieRingModule L Q
inst✝ : LieModule R L Q
f : M →ₗ⁅R,L⁆ N →ₗ[R] P
⊢ ↑(↑(liftLie R L M N P) f) = ↑(↑(lift R L M N P) ↑f)

tactic: ext (m n)
state_before: R : Type u
inst✝¹⁸ : CommRing R
L : Type v
M : Type w
N : Type w₁
P : Type w₂
Q : Type w₃
inst✝¹⁷ : LieRing L
inst✝¹⁶ : LieAlgebra R L
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
inst✝¹¹ : AddCommGroup N
inst✝¹⁰ : Module R N
inst✝⁹ : LieRingModule L N
inst✝⁸ : LieModule R L N
inst✝⁷ : AddCommGroup P
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L P
inst✝⁴ : LieModule R L P
inst✝³ : AddCommGroup Q
inst✝² : Module R Q
inst✝¹ : LieRingModule L Q
inst✝ : LieModule R L Q
f : M →ₗ⁅R,L⁆ N →ₗ[R] P
⊢ ↑(↑(liftLie R L M N P) f) = ↑(lift R L M N P) ↑f

tactic: simp only [liftLie, LinearEquiv.trans_apply, LieModuleEquiv.coe_to_linearEquiv,
  coe_linearMap_maxTrivLinearMapEquivLieModuleHom, coe_maxTrivEquiv_apply,
  coe_linearMap_maxTrivLinearMapEquivLieModuleHom_symm]
state_before: case H.h.h
R : Type u
inst✝¹⁸ : CommRing R
L : Type v
M : Type w
N : Type w₁
P : Type w₂
Q : Type w₃
inst✝¹⁷ : LieRing L
inst✝¹⁶ : LieAlgebra R L
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
inst✝¹¹ : AddCommGroup N
inst✝¹⁰ : Module R N
inst✝⁹ : LieRingModule L N
inst✝⁸ : LieModule R L N
inst✝⁷ : AddCommGroup P
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L P
inst✝⁴ : LieModule R L P
inst✝³ : AddCommGroup Q
inst✝² : Module R Q
inst✝¹ : LieRingModule L Q
inst✝ : LieModule R L Q
f : M →ₗ⁅R,L⁆ N →ₗ[R] P
m : M
n : N
⊢ ↑(↑(LinearMap.compr₂ (mk R M N) ↑(↑(liftLie R L M N P) f)) m) n =
    ↑(↑(LinearMap.compr₂ (mk R M N) (↑(lift R L M N P) ↑f)) m) n

tactic: rw [← this, LieModuleHom.coe_toLinearMap]
state_before: R : Type u
inst✝¹⁸ : CommRing R
L : Type v
M : Type w
N : Type w₁
P : Type w₂
Q : Type w₃
inst✝¹⁷ : LieRing L
inst✝¹⁶ : LieAlgebra R L
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
inst✝¹¹ : AddCommGroup N
inst✝¹⁰ : Module R N
inst✝⁹ : LieRingModule L N
inst✝⁸ : LieModule R L N
inst✝⁷ : AddCommGroup P
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L P
inst✝⁴ : LieModule R L P
inst✝³ : AddCommGroup Q
inst✝² : Module R Q
inst✝¹ : LieRingModule L Q
inst✝ : LieModule R L Q
f : M →ₗ⁅R,L⁆ N →ₗ[R] P
this : ↑(↑(liftLie R L M N P) f) = ↑(lift R L M N P) ↑f
⊢ ↑(↑(liftLie R L M N P) f) = ↑(↑(lift R L M N P) ↑f)
Theorem: mem_nhdsWithin_Iio_iff_exists_Ico_subset
File: Mathlib/Topology/Order/Basic.lean

tactic: have : ofDual ⁻¹' s ∈ 𝓝[>] toDual a ↔ _ := mem_nhdsWithin_Ioi_iff_exists_Ioc_subset
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁴ : TopologicalSpace α
inst✝³ : LinearOrder α
inst✝² : OrderTopology α
inst✝¹ : NoMinOrder α
inst✝ : DenselyOrdered α
a : α
s : Set α
⊢ s ∈ 𝓝[Iio a] a ↔ ∃ l, l ∈ Iio a ∧ Ico l a ⊆ s

tactic: simpa only [OrderDual.exists, exists_prop, dual_Ioc] using this
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁴ : TopologicalSpace α
inst✝³ : LinearOrder α
inst✝² : OrderTopology α
inst✝¹ : NoMinOrder α
inst✝ : DenselyOrdered α
a : α
s : Set α
this : ↑ofDual ⁻¹' s ∈ 𝓝[Ioi (↑toDual a)] ↑toDual a ↔ ∃ u, u ∈ Ioi (↑toDual a) ∧ Ioc (↑toDual a) u ⊆ ↑ofDual ⁻¹' s
⊢ s ∈ 𝓝[Iio a] a ↔ ∃ l, l ∈ Iio a ∧ Ico l a ⊆ s
Theorem: ContractingWith.dist_inequality
File: Mathlib/Topology/MetricSpace/Contracting.lean

tactic: rwa [le_div_iff hf.one_sub_K_pos, mul_comm, _root_.sub_mul, one_mul, sub_le_iff_le_add]
state_before: α : Type u_1
inst✝ : MetricSpace α
K : ℝ≥0
f : α → α
hf : ContractingWith K f
x y : α
this : dist x y ≤ dist x (f x) + dist y (f y) + ↑K * dist x y
⊢ dist x y ≤ (dist x (f x) + dist y (f y)) / (1 - ↑K)
Theorem: cauchySeq_tendsto_of_isComplete
File: Mathlib/Topology/UniformSpace/Cauchy.lean

tactic: rwa [image_univ, range_subset_iff]
state_before: α : Type u
β : Type v
inst✝¹ : UniformSpace α
inst✝ : SemilatticeSup β
K : Set α
h₁ : IsComplete K
u : β → α
h₂ : ∀ (n : β), u n ∈ K
h₃ : CauchySeq u
⊢ u '' univ ⊆ K
Theorem: Polynomial.mirror_mul_of_domain
File: Mathlib/Data/Polynomial/Mirror.lean

tactic: by_cases hp : p = 0
state_before: R : Type u_1
inst✝¹ : Ring R
p q : R[X]
inst✝ : NoZeroDivisors R
⊢ mirror (p * q) = mirror p * mirror q

tactic: by_cases hq : q = 0
state_before: case neg
R : Type u_1
inst✝¹ : Ring R
p q : R[X]
inst✝ : NoZeroDivisors R
hp : ¬p = 0
⊢ mirror (p * q) = mirror p * mirror q

tactic: rw [mirror, mirror, mirror, reverse_mul_of_domain, natTrailingDegree_mul hp hq, pow_add]
state_before: case neg
R : Type u_1
inst✝¹ : Ring R
p q : R[X]
inst✝ : NoZeroDivisors R
hp : ¬p = 0
hq : ¬q = 0
⊢ mirror (p * q) = mirror p * mirror q

tactic: rw [mul_assoc, ← mul_assoc q.reverse, ← X_pow_mul (p := reverse q)]
state_before: case neg
R : Type u_1
inst✝¹ : Ring R
p q : R[X]
inst✝ : NoZeroDivisors R
hp : ¬p = 0
hq : ¬q = 0
⊢ reverse p * reverse q * (X ^ natTrailingDegree p * X ^ natTrailingDegree q) =
    reverse p * X ^ natTrailingDegree p * (reverse q * X ^ natTrailingDegree q)

tactic: repeat' rw [mul_assoc]
state_before: case neg
R : Type u_1
inst✝¹ : Ring R
p q : R[X]
inst✝ : NoZeroDivisors R
hp : ¬p = 0
hq : ¬q = 0
⊢ reverse p * (X ^ natTrailingDegree p * reverse q * X ^ natTrailingDegree q) =
    reverse p * X ^ natTrailingDegree p * (reverse q * X ^ natTrailingDegree q)

tactic: rw [hp, MulZeroClass.zero_mul, mirror_zero, MulZeroClass.zero_mul]
state_before: case pos
R : Type u_1
inst✝¹ : Ring R
p q : R[X]
inst✝ : NoZeroDivisors R
hp : p = 0
⊢ mirror (p * q) = mirror p * mirror q

tactic: rw [hq, MulZeroClass.mul_zero, mirror_zero, MulZeroClass.mul_zero]
state_before: case pos
R : Type u_1
inst✝¹ : Ring R
p q : R[X]
inst✝ : NoZeroDivisors R
hp : ¬p = 0
hq : q = 0
⊢ mirror (p * q) = mirror p * mirror q

tactic: rw [mul_assoc]
state_before: case neg
R : Type u_1
inst✝¹ : Ring R
p q : R[X]
inst✝ : NoZeroDivisors R
hp : ¬p = 0
hq : ¬q = 0
⊢ reverse p * (X ^ natTrailingDegree p * (reverse q * X ^ natTrailingDegree q)) =
    reverse p * X ^ natTrailingDegree p * (reverse q * X ^ natTrailingDegree q)
Theorem: Nat.modCore_eq_mod
File: src/lean/Init/Data/Nat/Div.lean

tactic: cases x with
| zero =>
  rw [Nat.modCore]
  exact if_neg fun ⟨hlt, hle⟩ => Nat.lt_irrefl _ (Nat.lt_of_lt_of_le hlt hle)
| succ x => rfl
state_before: x y : Nat
⊢ Nat.modCore x y = x % y

tactic: rw [Nat.modCore]
state_before: case zero
y : Nat
⊢ Nat.modCore zero y = zero % y

tactic: exact if_neg fun ⟨hlt, hle⟩ => Nat.lt_irrefl _ (Nat.lt_of_lt_of_le hlt hle)
state_before: case zero
y : Nat
⊢ ite (0 < y ∧ y ≤ zero) (Nat.modCore (zero - y) y) zero = zero % y

tactic: rfl
state_before: case succ
y x : Nat
⊢ Nat.modCore (succ x) y = succ x % y