tasksource/leandojo huggingface dataset:
Theorem: List.sublists_eq_sublistsAux
File: Mathlib/Data/List/Sublists.lean

tactic: simp only [sublists, sublistsAux_eq_array_foldl, Array.foldr_eq_foldr_data]
state_before: α : Type u
β : Type v
γ : Type w
l : List α
⊢ sublists l = foldr sublistsAux [[]] l

tactic: rw [← foldr_hom Array.toList]
state_before: α : Type u
β : Type v
γ : Type w
l : List α
⊢ Array.toList
      (foldr
        (fun a arr =>
          Array.foldl (fun r l => Array.push (Array.push r l) (a :: l)) (Array.mkEmpty (Array.size arr * 2)) arr 0
            (Array.size arr))
        #[[]] l) =
    foldr
      (fun a r =>
        Array.toList
          (Array.foldl (fun r l => Array.push (Array.push r l) (a :: l)) #[] (toArray r) 0 (Array.size (toArray r))))
      [[]] l

tactic: . rfl
state_before: α : Type u
β : Type v
γ : Type w
l : List α
⊢ foldr ?g₂ (Array.toList #[[]]) l =
    foldr
      (fun a r =>
        Array.toList
          (Array.foldl (fun r l => Array.push (Array.push r l) (a :: l)) #[] (toArray r) 0 (Array.size (toArray r))))
      [[]] l

case g₂
α : Type u
β : Type v
γ : Type w
l : List α
⊢ α → List (List α) → List (List α)

case H
α : Type u
β : Type v
γ : Type w
l : List α
⊢ ∀ (x : α) (y : Array (List α)),
    ?g₂ x (Array.toList y) =
      Array.toList
        (Array.foldl (fun r l => Array.push (Array.push r l) (x :: l)) (Array.mkEmpty (Array.size y * 2)) y 0
          (Array.size y))

tactic: . intros _ _; congr <;> simp
state_before: case H
α : Type u
β : Type v
γ : Type w
l : List α
⊢ ∀ (x : α) (y : Array (List α)),
    Array.toList
        (Array.foldl (fun r l => Array.push (Array.push r l) (x :: l)) #[] (toArray (Array.toList y)) 0
          (Array.size (toArray (Array.toList y)))) =
      Array.toList
        (Array.foldl (fun r l => Array.push (Array.push r l) (x :: l)) (Array.mkEmpty (Array.size y * 2)) y 0
          (Array.size y))

tactic: rfl
state_before: α : Type u
β : Type v
γ : Type w
l : List α
⊢ foldr ?g₂ (Array.toList #[[]]) l =
    foldr
      (fun a r =>
        Array.toList
          (Array.foldl (fun r l => Array.push (Array.push r l) (a :: l)) #[] (toArray r) 0 (Array.size (toArray r))))
      [[]] l

tactic: intros _ _
state_before: case H
α : Type u
β : Type v
γ : Type w
l : List α
⊢ ∀ (x : α) (y : Array (List α)),
    Array.toList
        (Array.foldl (fun r l => Array.push (Array.push r l) (x :: l)) #[] (toArray (Array.toList y)) 0
          (Array.size (toArray (Array.toList y)))) =
      Array.toList
        (Array.foldl (fun r l => Array.push (Array.push r l) (x :: l)) (Array.mkEmpty (Array.size y * 2)) y 0
          (Array.size y))

tactic: congr <;> simp
state_before: case H
α : Type u
β : Type v
γ : Type w
l : List α
x✝ : α
y✝ : Array (List α)
⊢ Array.toList
      (Array.foldl (fun r l => Array.push (Array.push r l) (x✝ :: l)) #[] (toArray (Array.toList y✝)) 0
        (Array.size (toArray (Array.toList y✝)))) =
    Array.toList
      (Array.foldl (fun r l => Array.push (Array.push r l) (x✝ :: l)) (Array.mkEmpty (Array.size y✝ * 2)) y✝ 0
        (Array.size y✝))
Theorem: NNReal.tendsto_atTop_zero_of_summable
File: Mathlib/Topology/Instances/NNReal.lean

tactic: rw [← Nat.cofinite_eq_atTop]
state_before: f : ℕ → ℝ≥0
hf : Summable f
⊢ Tendsto f atTop (𝓝 0)

tactic: exact tendsto_cofinite_zero_of_summable hf
state_before: f : ℕ → ℝ≥0
hf : Summable f
⊢ Tendsto f cofinite (𝓝 0)
Theorem: Int.ceil_add_le
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [ceil_le, Int.cast_add]
state_before: F : Type ?u.217435
α : Type u_1
β : Type ?u.217441
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ ⌈a + b⌉ ≤ ⌈a⌉ + ⌈b⌉

tactic: exact add_le_add (le_ceil _) (le_ceil _)
state_before: F : Type ?u.217435
α : Type u_1
β : Type ?u.217441
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ a + b ≤ ↑⌈a⌉ + ↑⌈b⌉
Theorem: InnerProductGeometry.angle_sub_eq_arcsin_of_inner_eq_zero
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

tactic: rw [← neg_eq_zero, ← inner_neg_right] at h
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
h0 : x ≠ 0 ∨ y ≠ 0
⊢ angle x (x - y) = Real.arcsin (‖y‖ / ‖x - y‖)

tactic: rw [or_comm, ← neg_ne_zero, or_comm] at h0
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x (-y) = 0
h0 : x ≠ 0 ∨ y ≠ 0
⊢ angle x (x - y) = Real.arcsin (‖y‖ / ‖x - y‖)

tactic: rw [sub_eq_add_neg, angle_add_eq_arcsin_of_inner_eq_zero h h0, norm_neg]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x (-y) = 0
h0 : x ≠ 0 ∨ -y ≠ 0
⊢ angle x (x - y) = Real.arcsin (‖y‖ / ‖x - y‖)
Theorem: rank_map_le
File: Mathlib/LinearAlgebra/Dimension.lean

tactic: simpa using lift_rank_map_le f p
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.51468
R : Type u
inst✝⁶ : Ring R
M : Type v
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
M' : Type v'
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
M₁ : Type v
inst✝¹ : AddCommGroup M₁
inst✝ : Module R M₁
f : M →ₗ[R] M₁
p : Submodule R M
⊢ Module.rank R { x // x ∈ Submodule.map f p } ≤ Module.rank R { x // x ∈ p }
Theorem: NonUnitalSubsemiring.prod_top
File: Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean

tactic: simp [mem_prod, MonoidHom.coe_fst]
state_before: R : Type u
S : Type v
T : Type w
inst✝³ : NonUnitalNonAssocSemiring R
M : Subsemigroup R
inst✝² : NonUnitalNonAssocSemiring S
inst✝¹ : NonUnitalNonAssocSemiring T
F : Type ?u.267604
inst✝ : NonUnitalRingHomClass F R S
s : NonUnitalSubsemiring R
x : R × S
⊢ x ∈ prod s ⊤ ↔ x ∈ comap (NonUnitalRingHom.fst R S) s
Theorem: Basis.reindexFinsetRange_apply
File: Mathlib/LinearAlgebra/Basis.lean

tactic: rcases x with ⟨bi, hbi⟩
state_before: ι : Type u_2
ι' : Type ?u.423699
R : Type u_3
R₂ : Type ?u.423705
K : Type ?u.423708
M : Type u_1
M' : Type ?u.423714
M'' : Type ?u.423717
V : Type u
V' : Type ?u.423722
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid M'
inst✝² : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x✝ : M
b' : Basis ι' R M'
e : ι ≃ ι'
inst✝¹ : Fintype ι
inst✝ : DecidableEq M
x : { x // x ∈ Finset.image (↑b) Finset.univ }
⊢ ↑(reindexFinsetRange b) x = ↑x

tactic: rcases Finset.mem_image.mp hbi with ⟨i, -, rfl⟩
state_before: case mk
ι : Type u_2
ι' : Type ?u.423699
R : Type u_3
R₂ : Type ?u.423705
K : Type ?u.423708
M : Type u_1
M' : Type ?u.423714
M'' : Type ?u.423717
V : Type u
V' : Type ?u.423722
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid M'
inst✝² : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x : M
b' : Basis ι' R M'
e : ι ≃ ι'
inst✝¹ : Fintype ι
inst✝ : DecidableEq M
bi : M
hbi : bi ∈ Finset.image (↑b) Finset.univ
⊢ ↑(reindexFinsetRange b) { val := bi, property := hbi } = ↑{ val := bi, property := hbi }

tactic: exact b.reindexFinsetRange_self i
state_before: case mk.intro.intro
ι : Type u_2
ι' : Type ?u.423699
R : Type u_3
R₂ : Type ?u.423705
K : Type ?u.423708
M : Type u_1
M' : Type ?u.423714
M'' : Type ?u.423717
V : Type u
V' : Type ?u.423722
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid M'
inst✝² : Module R M'
b b₁ : Basis ι R M
i✝ : ι
c : R
x : M
b' : Basis ι' R M'
e : ι ≃ ι'
inst✝¹ : Fintype ι
inst✝ : DecidableEq M
i : ι
hbi : ↑b i ∈ Finset.image (↑b) Finset.univ
⊢ ↑(reindexFinsetRange b) { val := ↑b i, property := hbi } = ↑{ val := ↑b i, property := hbi }
Theorem: Tuple.comp_perm_comp_sort_eq_comp_sort
File: Mathlib/Data/Fin/Tuple/Sort.lean

tactic: rw [Function.comp.assoc, ← Equiv.Perm.coe_mul]
state_before: n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
σ : Equiv.Perm (Fin n)
⊢ (f ∘ ↑σ) ∘ ↑(sort (f ∘ ↑σ)) = f ∘ ↑(sort f)

tactic: exact unique_monotone (monotone_sort (f ∘ σ)) (monotone_sort f)
state_before: n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
σ : Equiv.Perm (Fin n)
⊢ f ∘ ↑(σ * sort (f ∘ ↑σ)) = f ∘ ↑(sort f)
Theorem: Metric.hausdorffDist_nonneg
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: simp [hausdorffDist]
state_before: ι : Sort ?u.72517
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
⊢ 0 ≤ hausdorffDist s t
Theorem: List.Nodup.rotate_eq_self_iff
File: Mathlib/Data/List/Rotate.lean

tactic: constructor
state_before: α : Type u
l : List α
hl : Nodup l
n : ℕ
⊢ rotate l n = l ↔ n % length l = 0 ∨ l = []

tactic: intro h
state_before: case mp
α : Type u
l : List α
hl : Nodup l
n : ℕ
⊢ rotate l n = l → n % length l = 0 ∨ l = []

tactic: cases' l.length.zero_le.eq_or_lt with hl' hl'
state_before: case mp
α : Type u
l : List α
hl : Nodup l
n : ℕ
h : rotate l n = l
⊢ n % length l = 0 ∨ l = []

tactic: left
state_before: case mp.inr
α : Type u
l : List α
hl : Nodup l
n : ℕ
h : rotate l n = l
hl' : 0 < length l
⊢ n % length l = 0 ∨ l = []

tactic: rw [nodup_iff_nthLe_inj] at hl
state_before: case mp.inr.h
α : Type u
l : List α
hl : Nodup l
n : ℕ
h : rotate l n = l
hl' : 0 < length l
⊢ n % length l = 0

tactic: refine' hl _ _ (mod_lt _ hl') hl' _
state_before: case mp.inr.h
α : Type u
l : List α
hl : ∀ (i j : ℕ) (h₁ : i < length l) (h₂ : j < length l), nthLe l i h₁ = nthLe l j h₂ → i = j
n : ℕ
h : rotate l n = l
hl' : 0 < length l
⊢ n % length l = 0

tactic: rw [← nthLe_rotate' _ n]
state_before: case mp.inr.h
α : Type u
l : List α
hl : ∀ (i j : ℕ) (h₁ : i < length l) (h₂ : j < length l), nthLe l i h₁ = nthLe l j h₂ → i = j
n : ℕ
h : rotate l n = l
hl' : 0 < length l
⊢ nthLe l (n % length l) (_ : n % length l < length l) = nthLe l 0 hl'

tactic: simp_rw [h, tsub_add_cancel_of_le (mod_lt _ hl').le, mod_self]
state_before: case mp.inr.h
α : Type u
l : List α
hl : ∀ (i j : ℕ) (h₁ : i < length l) (h₂ : j < length l), nthLe l i h₁ = nthLe l j h₂ → i = j
n : ℕ
h : rotate l n = l
hl' : 0 < length l
⊢ nthLe (rotate l n) ((length l - n % length l + n % length l) % length l)
      (_ : (length l - n % length l + n % length l) % length l < length (rotate l n)) =
    nthLe l 0 hl'

tactic: simp [← length_eq_zero, ← hl']
state_before: case mp.inl
α : Type u
l : List α
hl : Nodup l
n : ℕ
h : rotate l n = l
hl' : 0 = length l
⊢ n % length l = 0 ∨ l = []

tactic: rintro (h | h)
state_before: case mpr
α : Type u
l : List α
hl : Nodup l
n : ℕ
⊢ n % length l = 0 ∨ l = [] → rotate l n = l

tactic: rw [← rotate_mod, h]
state_before: case mpr.inl
α : Type u
l : List α
hl : Nodup l
n : ℕ
h : n % length l = 0
⊢ rotate l n = l

tactic: exact rotate_zero l
state_before: case mpr.inl
α : Type u
l : List α
hl : Nodup l
n : ℕ
h : n % length l = 0
⊢ rotate l 0 = l

tactic: simp [h]
state_before: case mpr.inr
α : Type u
l : List α
hl : Nodup l
n : ℕ
h : l = []
⊢ rotate l n = l
Theorem: Metric.uniformity_edist
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: simp only [PseudoMetricSpace.uniformity_dist, dist_nndist, edist_nndist,
  Metric.uniformity_edist_aux]
state_before: α : Type u
β : Type v
X : Type ?u.158749
ι : Type ?u.158752
inst✝ : PseudoMetricSpace α
⊢ 𝓤 α = ⨅ (ε : ℝ≥0∞) (_ : ε > 0), 𝓟 {p | edist p.fst p.snd < ε}
Theorem: MeasureTheory.Measure.map_mono_of_aemeasurable
File: Mathlib/MeasureTheory/Measure/AEMeasurable.lean

tactic: simpa [hf, hs, hf.mono_measure h] using Measure.le_iff'.1 h (f ⁻¹' s)
state_before: ι : Type ?u.4971036
α : Type u_1
β : Type ?u.4971042
γ : Type ?u.4971045
δ : Type u_2
R : Type ?u.4971051
m0 : MeasurableSpace α
inst✝³ : MeasurableSpace β
inst✝² : MeasurableSpace γ
inst✝¹ : MeasurableSpace δ
f✝ g : α → β
μ ν : Measure α
inst✝ : Zero β
f : α → δ
h : μ ≤ ν
hf : AEMeasurable f
s : Set δ
hs : MeasurableSet s
⊢ ↑↑(map f μ) s ≤ ↑↑(map f ν) s
Theorem: realPart_smul
File: Mathlib/Data/Complex/Module.lean

tactic: conv_lhs =>
  rw [← re_add_im z]
state_before: A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
z : ℂ
a : A
⊢ ↑ℜ (z • a) = z.re • ↑ℜ a - z.im • ↑ℑ a

tactic: simp [-re_add_im, add_smul, ← smul_smul, sub_eq_add_neg]
state_before: A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
z : ℂ
a : A
⊢ ↑ℜ ((↑z.re + ↑z.im * I) • a) = z.re • ↑ℜ a - z.im • ↑ℑ a
Theorem: MeasureTheory.OuterMeasure.restrict_ofFunction
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: simp
state_before: α : Type ?u.156969
m : Set α → ℝ≥0∞
m_empty : m ∅ = 0
s : Set α
hm : Monotone m
⊢ (fun t => m (t ∩ s)) ∅ = 0

tactic: simp [m_empty]
state_before: α : Type ?u.156969
m : Set α → ℝ≥0∞
m_empty : m ∅ = 0
s : Set α
hm : Monotone m
⊢ m ∅ = 0

tactic: rw [restrict]
state_before: α : Type u_1
m : Set α → ℝ≥0∞
m_empty : m ∅ = 0
s : Set α
hm : Monotone m
⊢ ↑(restrict s) (OuterMeasure.ofFunction m m_empty) =
    OuterMeasure.ofFunction (fun t => m (t ∩ s)) (_ : (fun t => m (t ∩ s)) ∅ = 0)

tactic: simp only [LinearMap.comp_apply]
state_before: α : Type u_1
m : Set α → ℝ≥0∞
m_empty : m ∅ = 0
s : Set α
hm : Monotone m
⊢ ↑(LinearMap.comp (map Subtype.val) (comap Subtype.val)) (OuterMeasure.ofFunction m m_empty) =
    OuterMeasure.ofFunction (fun t => m (t ∩ s)) (_ : (fun t => m (t ∩ s)) ∅ = 0)

tactic: rw [comap_ofFunction _ (Or.inl hm)]
state_before: α : Type u_1
m : Set α → ℝ≥0∞
m_empty : m ∅ = 0
s : Set α
hm : Monotone m
⊢ ↑(map Subtype.val) (↑(comap Subtype.val) (OuterMeasure.ofFunction m m_empty)) =
    OuterMeasure.ofFunction (fun t => m (t ∩ s)) (_ : (fun t => m (t ∩ s)) ∅ = 0)

tactic: simp only [map_ofFunction Subtype.coe_injective, Subtype.image_preimage_coe]
state_before: α : Type u_1
m : Set α → ℝ≥0∞
m_empty : m ∅ = 0
s : Set α
hm : Monotone m
⊢ ↑(map Subtype.val)
      (OuterMeasure.ofFunction (fun s_1 => m (Subtype.val '' s_1)) (_ : (fun s_1 => m (Subtype.val '' s_1)) ∅ = 0)) =
    OuterMeasure.ofFunction (fun t => m (t ∩ s)) (_ : (fun t => m (t ∩ s)) ∅ = 0)
Theorem: Multiset.Nodup.add_iff
File: Mathlib/Data/Multiset/Nodup.lean

tactic: simp [nodup_add, d₁, d₂]
state_before: α : Type u_1
β : Type ?u.5533
γ : Type ?u.5536
r : α → α → Prop
s t : Multiset α
a : α
d₁ : Nodup s
d₂ : Nodup t
⊢ Nodup (s + t) ↔ Disjoint s t
Theorem: Padic.complete''
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: obtain ⟨x, hx⟩ := complete' f
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
f : CauSeq ℚ_[p] ↑padicNormE
⊢ ∃ q, ∀ (ε : ℚ), ε > 0 → ∃ N, ∀ (i : ℕ), i ≥ N → ↑padicNormE (↑f i - q) < ε

tactic: refine ⟨x, fun ε hε => ?_⟩
state_before: case intro
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : CauSeq ℚ_[p] ↑padicNormE
x : ℚ_[p]
hx : ∀ (ε : ℚ), ε > 0 → ∃ N, ∀ (i : ℕ), i ≥ N → ↑padicNormE (x - ↑f i) < ε
⊢ ∃ q, ∀ (ε : ℚ), ε > 0 → ∃ N, ∀ (i : ℕ), i ≥ N → ↑padicNormE (↑f i - q) < ε

tactic: obtain ⟨N, hN⟩ := hx ε hε
state_before: case intro
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : CauSeq ℚ_[p] ↑padicNormE
x : ℚ_[p]
hx : ∀ (ε : ℚ), ε > 0 → ∃ N, ∀ (i : ℕ), i ≥ N → ↑padicNormE (x - ↑f i) < ε
ε : ℚ
hε : ε > 0
⊢ ∃ N, ∀ (i : ℕ), i ≥ N → ↑padicNormE (↑f i - x) < ε

tactic: refine ⟨N, fun i hi => ?_⟩
state_before: case intro.intro
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : CauSeq ℚ_[p] ↑padicNormE
x : ℚ_[p]
hx : ∀ (ε : ℚ), ε > 0 → ∃ N, ∀ (i : ℕ), i ≥ N → ↑padicNormE (x - ↑f i) < ε
ε : ℚ
hε : ε > 0
N : ℕ
hN : ∀ (i : ℕ), i ≥ N → ↑padicNormE (x - ↑f i) < ε
⊢ ∃ N, ∀ (i : ℕ), i ≥ N → ↑padicNormE (↑f i - x) < ε

tactic: rw [padicNormE.map_sub]
state_before: case intro.intro
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : CauSeq ℚ_[p] ↑padicNormE
x : ℚ_[p]
hx : ∀ (ε : ℚ), ε > 0 → ∃ N, ∀ (i : ℕ), i ≥ N → ↑padicNormE (x - ↑f i) < ε
ε : ℚ
hε : ε > 0
N : ℕ
hN : ∀ (i : ℕ), i ≥ N → ↑padicNormE (x - ↑f i) < ε
i : ℕ
hi : i ≥ N
⊢ ↑padicNormE (↑f i - x) < ε

tactic: exact hN i hi
state_before: case intro.intro
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : CauSeq ℚ_[p] ↑padicNormE
x : ℚ_[p]
hx : ∀ (ε : ℚ), ε > 0 → ∃ N, ∀ (i : ℕ), i ≥ N → ↑padicNormE (x - ↑f i) < ε
ε : ℚ
hε : ε > 0
N : ℕ
hN : ∀ (i : ℕ), i ≥ N → ↑padicNormE (x - ↑f i) < ε
i : ℕ
hi : i ≥ N
⊢ ↑padicNormE (x - ↑f i) < ε
Theorem: Filter.nhds_iInf
File: Mathlib/Topology/Filter.lean

tactic: simp only [nhds_eq]
state_before: ι : Sort u_2
α : Type u_1
β : Type ?u.9675
X : Type ?u.9678
Y : Type ?u.9681
f : ι → Filter α
⊢ 𝓝 (⨅ (i : ι), f i) = ⨅ (i : ι), 𝓝 (f i)

tactic: apply lift'_iInf_of_map_univ <;> simp
state_before: ι : Sort u_2
α : Type u_1
β : Type ?u.9675
X : Type ?u.9678
Y : Type ?u.9681
f : ι → Filter α
⊢ Filter.lift' (⨅ (i : ι), f i) (Iic ∘ 𝓟) = ⨅ (i : ι), Filter.lift' (f i) (Iic ∘ 𝓟)
Theorem: LieAlgebra.lieCharacter_apply_lie'
File: Mathlib/Algebra/Lie/Character.lean

tactic: rw [LieRing.of_associative_ring_bracket, mul_comm, sub_self]
state_before: R : Type u
L : Type v
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
χ : LieCharacter R L
x y : L
⊢ ⁅↑χ x, ↑χ y⁆ = 0
Theorem: IsCompl.inf_left_le_of_le_sup_right
File: Mathlib/Order/Disjoint.lean

tactic: rw [h.symm.inf_eq_bot, sup_bot_eq]
state_before: α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : BoundedOrder α
a b x y z : α
h : IsCompl x y
hle : a ≤ b ⊔ y
⊢ b ⊓ x ⊔ y ⊓ x = b ⊓ x
Theorem: div_mul_eq_div_div
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.39118
G : Type ?u.39121
inst✝ : DivisionCommMonoid α
a b c d : α
⊢ a / (b * c) = a / b / c
Theorem: hasFDerivWithinAt_congr_set'
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

tactic: suffices 𝓝[s \ {y}] x = 𝓝[t \ {y}] x by simp only [HasFDerivWithinAt, this]
state_before: 𝕜 : Type u_2
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.440170
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.440265
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
y : E
h : s =ᶠ[𝓝[{y}ᶜ] x] t
⊢ HasFDerivWithinAt f f' (s \ {y}) x ↔ HasFDerivWithinAt f f' (t \ {y}) x

tactic: simpa only [set_eventuallyEq_iff_inf_principal, ← nhdsWithin_inter', diff_eq,
  inter_comm] using h
state_before: 𝕜 : Type u_2
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.440170
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.440265
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
y : E
h : s =ᶠ[𝓝[{y}ᶜ] x] t
⊢ 𝓝[s \ {y}] x = 𝓝[t \ {y}] x

tactic: simp only [HasFDerivWithinAt, this]
state_before: 𝕜 : Type u_2
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.440170
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.440265
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
y : E
h : s =ᶠ[𝓝[{y}ᶜ] x] t
this : 𝓝[s \ {y}] x = 𝓝[t \ {y}] x
⊢ HasFDerivWithinAt f f' (s \ {y}) x ↔ HasFDerivWithinAt f f' (t \ {y}) x
Theorem: CategoryTheory.Subobject.ofMkLEMk_comp_ofMkLE
File: Mathlib/CategoryTheory/Subobject/Basic.lean

tactic: simp only [ofMkLE, ofLEMk, ofLE, ofMkLEMk, ← Functor.map_comp underlying,
  assoc, Iso.hom_inv_id_assoc]
state_before: C : Type u₁
inst✝³ : Category C
X✝ Y Z : C
D : Type u₂
inst✝² : Category D
B A₁ A₂ : C
f : A₁ ⟶ B
inst✝¹ : Mono f
g : A₂ ⟶ B
inst✝ : Mono g
X : Subobject B
h₁ : mk f ≤ mk g
h₂ : mk g ≤ X
⊢ ofMkLEMk f g h₁ ≫ ofMkLE g X h₂ = ofMkLE f X (_ : mk f ≤ X)

tactic: congr 1
state_before: C : Type u₁
inst✝³ : Category C
X✝ Y Z : C
D : Type u₂
inst✝² : Category D
B A₁ A₂ : C
f : A₁ ⟶ B
inst✝¹ : Mono f
g : A₂ ⟶ B
inst✝ : Mono g
X : Subobject B
h₁ : mk f ≤ mk g
h₂ : mk g ≤ X
⊢ (underlyingIso f).inv ≫ underlying.map (LE.le.hom h₁ ≫ LE.le.hom h₂) =
    (underlyingIso f).inv ≫ underlying.map (LE.le.hom (_ : mk f ≤ X))
Theorem: MeasureTheory.measure_smul_null
File: Mathlib/MeasureTheory/Group/Action.lean

tactic: rwa [measure_smul]
state_before: G : Type u_2
M : Type ?u.42834
α : Type u_1
s✝ : Set α
m : MeasurableSpace α
inst✝⁴ : Group G
inst✝³ : MulAction G α
inst✝² : MeasurableSpace G
inst✝¹ : MeasurableSMul G α
c✝ : G
μ : Measure α
inst✝ : SMulInvariantMeasure G α μ
s : Set α
h : ↑↑μ s = 0
c : G
⊢ ↑↑μ (c • s) = 0
Theorem: Matrix.conjTranspose_ratCast_smul
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp
state_before: l : Type ?u.1027257
m : Type u_2
n : Type u_3
o : Type ?u.1027266
m' : o → Type ?u.1027271
n' : o → Type ?u.1027276
R : Type u_1
S : Type ?u.1027282
α : Type v
β : Type w
γ : Type ?u.1027289
inst✝³ : DivisionRing R
inst✝² : AddCommGroup α
inst✝¹ : StarAddMonoid α
inst✝ : Module R α
c : ℚ
M : Matrix m n α
⊢ ∀ (i : n) (j : m), (↑c • M)ᴴ i j = (↑c • Mᴴ) i j
Theorem: contDiffOn_succ_iff_fderiv_of_open
File: Mathlib/Analysis/Calculus/ContDiffDef.lean

tactic: rw [contDiffOn_succ_iff_fderivWithin hs.uniqueDiffOn]
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
hs : IsOpen s
⊢ ContDiffOn 𝕜 (↑(n + 1)) f s ↔ DifferentiableOn 𝕜 f s ∧ ContDiffOn 𝕜 (↑n) (fun y => fderiv 𝕜 f y) s

tactic: exact Iff.rfl.and (contDiffOn_congr fun x hx ↦ fderivWithin_of_open hs hx)
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
hs : IsOpen s
⊢ DifferentiableOn 𝕜 f s ∧ ContDiffOn 𝕜 (↑n) (fun y => fderivWithin 𝕜 f s y) s ↔
    DifferentiableOn 𝕜 f s ∧ ContDiffOn 𝕜 (↑n) (fun y => fderiv 𝕜 f y) s
Theorem: CompleteLattice.independent_iff_supIndep_univ
File: Mathlib/Order/SupIndep.lean

tactic: classical
  simp [Finset.supIndep_iff_disjoint_erase, CompleteLattice.Independent, Finset.sup_eq_iSup]
state_before: α : Type u_1
β : Type ?u.67094
ι : Type u_2
ι' : Type ?u.67100
inst✝¹ : CompleteLattice α
inst✝ : Fintype ι
f : ι → α
⊢ Independent f ↔ Finset.SupIndep Finset.univ f

tactic: simp [Finset.supIndep_iff_disjoint_erase, CompleteLattice.Independent, Finset.sup_eq_iSup]
state_before: α : Type u_1
β : Type ?u.67094
ι : Type u_2
ι' : Type ?u.67100
inst✝¹ : CompleteLattice α
inst✝ : Fintype ι
f : ι → α
⊢ Independent f ↔ Finset.SupIndep Finset.univ f
Theorem: LucasLehmer.X.coe_nat
File: Mathlib/NumberTheory/LucasLehmer.lean

tactic: ext <;> simp
state_before: q : ℕ+
n : ℕ
⊢ ↑↑n = ↑n