tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.Measure.forall_measure_inter_spanningSets_eq_zero
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: nth_rw 2 [show s = ⋃ n, s ∩ spanningSets μ n by
    rw [← inter_iUnion, iUnion_spanningSets, inter_univ] ]
state_before: α : Type u_1
β : Type ?u.732836
γ : Type ?u.732839
δ : Type ?u.732842
ι : Type ?u.732845
R : Type ?u.732848
R' : Type ?u.732851
m0 : MeasurableSpace α
inst✝³ : MeasurableSpace β
inst✝² : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
inst✝¹ : MeasurableSpace α
μ : Measure α
inst✝ : SigmaFinite μ
s : Set α
⊢ (∀ (n : ℕ), ↑↑μ (s ∩ spanningSets μ n) = 0) ↔ ↑↑μ s = 0

tactic: rw [measure_iUnion_null_iff]
state_before: α : Type u_1
β : Type ?u.732836
γ : Type ?u.732839
δ : Type ?u.732842
ι : Type ?u.732845
R : Type ?u.732848
R' : Type ?u.732851
m0 : MeasurableSpace α
inst✝³ : MeasurableSpace β
inst✝² : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
inst✝¹ : MeasurableSpace α
μ : Measure α
inst✝ : SigmaFinite μ
s : Set α
⊢ (∀ (n : ℕ), ↑↑μ (s ∩ spanningSets μ n) = 0) ↔ ↑↑μ (⋃ (n : ℕ), s ∩ spanningSets μ n) = 0

tactic: rw [← inter_iUnion, iUnion_spanningSets, inter_univ]
state_before: α : Type u_1
β : Type ?u.732836
γ : Type ?u.732839
δ : Type ?u.732842
ι : Type ?u.732845
R : Type ?u.732848
R' : Type ?u.732851
m0 : MeasurableSpace α
inst✝³ : MeasurableSpace β
inst✝² : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
inst✝¹ : MeasurableSpace α
μ : Measure α
inst✝ : SigmaFinite μ
s : Set α
⊢ s = ⋃ (n : ℕ), s ∩ spanningSets μ n
Theorem: Real.cosh_neg
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp
state_before: x y : ℝ
⊢ ↑(cosh (-x)) = ↑(cosh x)
Theorem: List.Perm.filterMap
File: Mathlib/Data/List/Perm.lean

tactic: induction p with
| nil => simp
| cons x _p IH =>
  simp only [filterMap]
  cases h : f x
    <;> simp [h, filterMap, IH, Perm.cons]
| swap x y l₂ =>
  simp only [filterMap]
  cases hx : f x
    <;> cases hy : f y
      <;> simp [hx, hy, filterMap, swap]
| trans _p₁ _p₂ IH₁ IH₂ =>
  exact IH₁.trans IH₂
state_before: α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
f : α → Option β
l₁ l₂ : List α
p : l₁ ~ l₂
⊢ List.filterMap f l₁ ~ List.filterMap f l₂

tactic: simp
state_before: case nil
α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
f : α → Option β
l₁ l₂ : List α
⊢ List.filterMap f [] ~ List.filterMap f []

tactic: simp only [filterMap]
state_before: case cons
α : Type uu
β : Type vv
l₁✝¹ l₂✝¹ : List α
f : α → Option β
l₁ l₂ : List α
x : α
l₁✝ l₂✝ : List α
_p : l₁✝ ~ l₂✝
IH : List.filterMap f l₁✝ ~ List.filterMap f l₂✝
⊢ List.filterMap f (x :: l₁✝) ~ List.filterMap f (x :: l₂✝)

tactic: cases h : f x
  <;> simp [h, filterMap, IH, Perm.cons]
state_before: case cons
α : Type uu
β : Type vv
l₁✝¹ l₂✝¹ : List α
f : α → Option β
l₁ l₂ : List α
x : α
l₁✝ l₂✝ : List α
_p : l₁✝ ~ l₂✝
IH : List.filterMap f l₁✝ ~ List.filterMap f l₂✝
⊢ List.filterMap f (x :: l₁✝) ~ List.filterMap f (x :: l₂✝)

tactic: simp only [filterMap]
state_before: case swap
α : Type uu
β : Type vv
l₁✝ l₂✝¹ : List α
f : α → Option β
l₁ l₂✝ : List α
x y : α
l₂ : List α
⊢ List.filterMap f (y :: x :: l₂) ~ List.filterMap f (x :: y :: l₂)

tactic: cases hx : f x
  <;> cases hy : f y
    <;> simp [hx, hy, filterMap, swap]
state_before: case swap
α : Type uu
β : Type vv
l₁✝ l₂✝¹ : List α
f : α → Option β
l₁ l₂✝ : List α
x y : α
l₂ : List α
⊢ List.filterMap f (y :: x :: l₂) ~ List.filterMap f (x :: y :: l₂)

tactic: exact IH₁.trans IH₂
state_before: case trans
α : Type uu
β : Type vv
l₁✝¹ l₂✝¹ : List α
f : α → Option β
l₁ l₂ l₁✝ l₂✝ l₃✝ : List α
_p₁ : l₁✝ ~ l₂✝
_p₂ : l₂✝ ~ l₃✝
IH₁ : List.filterMap f l₁✝ ~ List.filterMap f l₂✝
IH₂ : List.filterMap f l₂✝ ~ List.filterMap f l₃✝
⊢ List.filterMap f l₁✝ ~ List.filterMap f l₃✝
Theorem: InnerProductSpace.Core.inner_self_eq_zero
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rintro rfl
state_before: 𝕜 : Type u_1
E : Type ?u.538902
F : Type u_2
inst✝² : IsROrC 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x : F
⊢ x = 0 → inner x x = 0

tactic: exact inner_zero_left _
state_before: 𝕜 : Type u_1
E : Type ?u.538902
F : Type u_2
inst✝² : IsROrC 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
⊢ inner 0 0 = 0
Theorem: BoxIntegral.Box.splitUpper_eq_self
File: Mathlib/Analysis/BoxIntegral/Partition/Split.lean

tactic: simp [splitUpper, update_eq_iff]
state_before: ι : Type u_1
M : Type ?u.15762
n : ℕ
I : Box ι
i : ι
x : ℝ
y : ι → ℝ
⊢ splitUpper I i x = ↑I ↔ x ≤ lower I i
Theorem: tendsto_inv_nhdsWithin_Ioi
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: simp [tendsto_principal_principal]
state_before: α : Type u
β : Type v
G : Type w
H : Type x
inst✝⁶ : TopologicalSpace G
inst✝⁵ : Group G
inst✝⁴ : TopologicalGroup G
inst✝³ : TopologicalSpace α
f : α → G
s : Set α
x : α
inst✝² : TopologicalSpace H
inst✝¹ : OrderedCommGroup H
inst✝ : ContinuousInv H
a : H
⊢ Tendsto (fun a => a⁻¹) (𝓟 (Ioi a)) (𝓟 (Iio a⁻¹))
Theorem: Set.Ico_inter_Iio
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: simp (config := { contextual := true }) [iff_def]
state_before: α : Type u_1
β : Type ?u.204664
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
a a₁ a₂ b b₁ b₂ c d : α
⊢ ∀ (x : α), x ∈ Ico a b ∩ Iio c ↔ x ∈ Ico a (min b c)
Theorem: Metric.isOpen_iff
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: simp only [isOpen_iff_mem_nhds, mem_nhds_iff]
state_before: α : Type u
β : Type v
X : Type ?u.96096
ι : Type ?u.96099
inst✝ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
⊢ IsOpen s ↔ ∀ (x : α), x ∈ s → ∃ ε, ε > 0 ∧ ball x ε ⊆ s
Theorem: Submodule.iInf_coe
File: Mathlib/Algebra/Module/Submodule/Lattice.lean

tactic: rw [iInf, sInf_coe]
state_before: R : Type u_2
S : Type ?u.139553
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Module S M
inst✝¹ : SMul S R
inst✝ : IsScalarTower S R M
p✝ q : Submodule R M
ι : Sort u_1
p : ι → Submodule R M
⊢ ↑(⨅ (i : ι), p i) = ⋂ (i : ι), ↑(p i)

tactic: simp only [Set.mem_range, Set.iInter_exists, Set.iInter_iInter_eq']
state_before: R : Type u_2
S : Type ?u.139553
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Module S M
inst✝¹ : SMul S R
inst✝ : IsScalarTower S R M
p✝ q : Submodule R M
ι : Sort u_1
p : ι → Submodule R M
⊢ (⋂ (p_1 : Submodule R M) (_ : p_1 ∈ Set.range fun i => p i), ↑p_1) = ⋂ (i : ι), ↑(p i)
Theorem: ZMod.valMinAbs_mul_two_eq_iff
File: Mathlib/Data/ZMod/Basic.lean

tactic: cases' n with n
state_before: n : ℕ
a : ZMod n
⊢ valMinAbs a * 2 = ↑n ↔ 2 * val a = n

tactic: by_cases h : a.val ≤ n.succ / 2
state_before: case succ
n : ℕ
a : ZMod (Nat.succ n)
⊢ valMinAbs a * 2 = ↑(Nat.succ n) ↔ 2 * val a = Nat.succ n

tactic: apply iff_of_false _ (mt _ h)
state_before: case neg
n : ℕ
a : ZMod (Nat.succ n)
h : ¬val a ≤ Nat.succ n / 2
⊢ valMinAbs a * 2 = ↑(Nat.succ n) ↔ 2 * val a = Nat.succ n

tactic: simp
state_before: case zero
a : ZMod Nat.zero
⊢ valMinAbs a * 2 = ↑Nat.zero ↔ 2 * val a = Nat.zero

tactic: dsimp [valMinAbs]
state_before: case pos
n : ℕ
a : ZMod (Nat.succ n)
h : val a ≤ Nat.succ n / 2
⊢ valMinAbs a * 2 = ↑(Nat.succ n) ↔ 2 * val a = Nat.succ n

tactic: rw [if_pos h, ← Int.coe_nat_inj', Nat.cast_mul, Nat.cast_two, mul_comm]
state_before: case pos
n : ℕ
a : ZMod (Nat.succ n)
h : val a ≤ Nat.succ n / 2
⊢ (if val a ≤ Nat.succ n / 2 then ↑(val a) else ↑(val a) - ↑(Nat.succ n)) * 2 = ↑(Nat.succ n) ↔ 2 * val a = Nat.succ n

tactic: intro he
state_before: n : ℕ
a : ZMod (Nat.succ n)
h : ¬val a ≤ Nat.succ n / 2
⊢ ¬valMinAbs a * 2 = ↑(Nat.succ n)

tactic: rw [← a.valMinAbs_nonneg_iff, ← mul_nonneg_iff_left_nonneg_of_pos, he] at h
state_before: n : ℕ
a : ZMod (Nat.succ n)
h : ¬val a ≤ Nat.succ n / 2
he : valMinAbs a * 2 = ↑(Nat.succ n)
⊢ False

tactic: exacts [h (Nat.cast_nonneg _), zero_lt_two]
state_before: n : ℕ
a : ZMod (Nat.succ n)
h✝ : ¬0 ≤ valMinAbs a
h : ¬0 ≤ ↑(Nat.succ n)
he : valMinAbs a * 2 = ↑(Nat.succ n)
⊢ False

n : ℕ
a : ZMod (Nat.succ n)
h : ¬0 ≤ valMinAbs a
he : valMinAbs a * 2 = ↑(Nat.succ n)
⊢ 0 < 2

tactic: rw [mul_comm]
state_before: n : ℕ
a : ZMod (Nat.succ n)
h : ¬val a ≤ Nat.succ n / 2
⊢ 2 * val a = Nat.succ n → val a ≤ Nat.succ n / 2

tactic: exact fun h => (Nat.le_div_iff_mul_le zero_lt_two).2 h.le
state_before: n : ℕ
a : ZMod (Nat.succ n)
h : ¬val a ≤ Nat.succ n / 2
⊢ val a * 2 = Nat.succ n → val a ≤ Nat.succ n / 2
Theorem: List.reverse_append
File: src/lean/Init/Data/List/Basic.lean

tactic: induction as generalizing bs with
| nil => simp
| cons a as ih => simp [ih]; rw [append_assoc]
state_before: α : Type u
β : Type v
γ : Type w
as bs : List α
⊢ reverse (as ++ bs) = reverse bs ++ reverse as

tactic: simp
state_before: case nil
α : Type u
β : Type v
γ : Type w
bs : List α
⊢ reverse (nil ++ bs) = reverse bs ++ reverse nil

tactic: simp [ih]
state_before: case cons
α : Type u
β : Type v
γ : Type w
a : α
as : List α
ih : ∀ (bs : List α), reverse (as ++ bs) = reverse bs ++ reverse as
bs : List α
⊢ reverse (a :: as ++ bs) = reverse bs ++ reverse (a :: as)

tactic: rw [append_assoc]
state_before: case cons
α : Type u
β : Type v
γ : Type w
a : α
as : List α
ih : ∀ (bs : List α), reverse (as ++ bs) = reverse bs ++ reverse as
bs : List α
⊢ reverse bs ++ reverse as ++ a :: nil = reverse bs ++ (reverse as ++ a :: nil)
Theorem: strictConcaveOn_sqrt_mul_log_Ioi
File: Mathlib/Analysis/Convex/SpecificFunctions/Deriv.lean

tactic: apply strictConcaveOn_of_deriv2_neg' (convex_Ioi 1) _ fun x hx => ?_
state_before: ⊢ StrictConcaveOn ℝ (Ioi 1) fun x => sqrt x * log x

tactic: exact continuous_sqrt.continuousOn.mul
  (continuousOn_log.mono fun x hx => ne_of_gt (zero_lt_one.trans hx))
state_before: ⊢ ContinuousOn (fun x => sqrt x * log x) (Ioi 1)

tactic: rw [deriv2_sqrt_mul_log x]
state_before: x : ℝ
hx : x ∈ Ioi 1
⊢ (deriv^[2]) (fun x => sqrt x * log x) x < 0

tactic: exact div_neg_of_neg_of_pos (neg_neg_of_pos (log_pos hx))
  (mul_pos four_pos (pow_pos (sqrt_pos.mpr (zero_lt_one.trans hx)) 3))
state_before: x : ℝ
hx : x ∈ Ioi 1
⊢ -log x / (↑4 * sqrt x ^ 3) < 0
Theorem: Function.Periodic.const_add
File: Mathlib/Algebra/Periodic.lean

tactic: simpa [add_assoc] using h (a + x)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.82300
f g : α → β
c c₁ c₂ x✝ : α
inst✝ : AddSemigroup α
h : Periodic f c
a x : α
⊢ (fun x => f (a + x)) (x + c) = (fun x => f (a + x)) x
Theorem: Stirling.stirlingSeq'_bounded_by_pos_constant
File: Mathlib/Analysis/SpecialFunctions/Stirling.lean

tactic: cases' log_stirlingSeq_bounded_by_constant with c h
state_before: ⊢ ∃ a, 0 < a ∧ ∀ (n : ℕ), a ≤ stirlingSeq (succ n)

tactic: refine' ⟨exp c, exp_pos _, fun n => _⟩
state_before: case intro
c : ℝ
h : ∀ (n : ℕ), c ≤ Real.log (stirlingSeq (succ n))
⊢ ∃ a, 0 < a ∧ ∀ (n : ℕ), a ≤ stirlingSeq (succ n)

tactic: rw [← le_log_iff_exp_le (stirlingSeq'_pos n)]
state_before: case intro
c : ℝ
h : ∀ (n : ℕ), c ≤ Real.log (stirlingSeq (succ n))
n : ℕ
⊢ exp c ≤ stirlingSeq (succ n)

tactic: exact h n
state_before: case intro
c : ℝ
h : ∀ (n : ℕ), c ≤ Real.log (stirlingSeq (succ n))
n : ℕ
⊢ c ≤ Real.log (stirlingSeq (succ n))
Theorem: uniformity_prod_eq_prod
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: rw [map_swap4_eq_comap, uniformity_prod_eq_comap_prod]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.154039
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
⊢ 𝓤 (α × β) = map (fun p => ((p.fst.fst, p.snd.fst), p.fst.snd, p.snd.snd)) (𝓤 α ×ˢ 𝓤 β)
Theorem: Nat.mul_div_cancel_left
File: Std/Data/Nat/Lemmas.lean

tactic: rw [Nat.mul_comm, Nat.mul_div_cancel _ H]
state_before: m n : Nat
H : 0 < n
⊢ n * m / n = m
Theorem: CategoryTheory.Abelian.exact_tfae
File: Mathlib/CategoryTheory/Abelian/Exact.lean

tactic: tfae_have 1 ↔ 2
state_before: C : Type u₁
inst✝¹ : Category C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ TFAE [Exact f g, f ≫ g = 0 ∧ kernel.ι g ≫ cokernel.π f = 0, imageSubobject f = kernelSubobject g]

tactic: tfae_have 1 ↔ 3
state_before: C : Type u₁
inst✝¹ : Category C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
tfae_1_iff_2 : Exact f g ↔ f ≫ g = 0 ∧ kernel.ι g ≫ cokernel.π f = 0
⊢ TFAE [Exact f g, f ≫ g = 0 ∧ kernel.ι g ≫ cokernel.π f = 0, imageSubobject f = kernelSubobject g]

tactic: tfae_finish
state_before: C : Type u₁
inst✝¹ : Category C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
tfae_1_iff_2 : Exact f g ↔ f ≫ g = 0 ∧ kernel.ι g ≫ cokernel.π f = 0
tfae_1_iff_3 : Exact f g ↔ imageSubobject f = kernelSubobject g
⊢ TFAE [Exact f g, f ≫ g = 0 ∧ kernel.ι g ≫ cokernel.π f = 0, imageSubobject f = kernelSubobject g]

tactic: apply exact_iff
state_before: case tfae_1_iff_2
C : Type u₁
inst✝¹ : Category C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ Exact f g ↔ f ≫ g = 0 ∧ kernel.ι g ≫ cokernel.π f = 0

tactic: apply exact_iff_image_eq_kernel
state_before: case tfae_1_iff_3
C : Type u₁
inst✝¹ : Category C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
tfae_1_iff_2 : Exact f g ↔ f ≫ g = 0 ∧ kernel.ι g ≫ cokernel.π f = 0
⊢ Exact f g ↔ imageSubobject f = kernelSubobject g
Theorem: Int.le_neg_of_le_neg
File: Std/Data/Int/Lemmas.lean

tactic: have h := Int.neg_le_neg h
state_before: a b : Int
h : a ≤ -b
⊢ b ≤ -a

tactic: rwa [Int.neg_neg] at h
state_before: a b : Int
h✝ : a ≤ -b
h : - -b ≤ -a
⊢ b ≤ -a
Theorem: List.insertNth_of_length_lt
File: Mathlib/Data/List/Basic.lean

tactic: induction' l with hd tl IH generalizing n
state_before: ι : Type ?u.122867
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
l : List α
x : α
n : ℕ
h : length l < n
⊢ insertNth n x l = l

tactic: cases n
state_before: case nil
ι : Type ?u.122867
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
l : List α
x : α
n✝ : ℕ
h✝ : length l < n✝
n : ℕ
h : length [] < n
⊢ insertNth n x [] = []

tactic: simp at h
state_before: case nil.zero
ι : Type ?u.122867
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
l : List α
x : α
n : ℕ
h✝ : length l < n
h : length [] < zero
⊢ insertNth zero x [] = []

tactic: simp
state_before: case nil.succ
ι : Type ?u.122867
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
l : List α
x : α
n : ℕ
h✝ : length l < n
n✝ : ℕ
h : length [] < succ n✝
⊢ insertNth (succ n✝) x [] = []

tactic: cases n
state_before: case cons
ι : Type ?u.122867
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
l : List α
x : α
n✝ : ℕ
h✝ : length l < n✝
hd : α
tl : List α
IH : ∀ (n : ℕ), length tl < n → insertNth n x tl = tl
n : ℕ
h : length (hd :: tl) < n
⊢ insertNth n x (hd :: tl) = hd :: tl

tactic: simp at h
state_before: case cons.zero
ι : Type ?u.122867
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
l : List α
x : α
n : ℕ
h✝ : length l < n
hd : α
tl : List α
IH : ∀ (n : ℕ), length tl < n → insertNth n x tl = tl
h : length (hd :: tl) < zero
⊢ insertNth zero x (hd :: tl) = hd :: tl

tactic: simp only [Nat.succ_lt_succ_iff, length] at h
state_before: case cons.succ
ι : Type ?u.122867
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
l : List α
x : α
n : ℕ
h✝ : length l < n
hd : α
tl : List α
IH : ∀ (n : ℕ), length tl < n → insertNth n x tl = tl
n✝ : ℕ
h : length (hd :: tl) < succ n✝
⊢ insertNth (succ n✝) x (hd :: tl) = hd :: tl

tactic: simpa using IH _ h
state_before: case cons.succ
ι : Type ?u.122867
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
l : List α
x : α
n : ℕ
h✝ : length l < n
hd : α
tl : List α
IH : ∀ (n : ℕ), length tl < n → insertNth n x tl = tl
n✝ : ℕ
h : length tl < n✝
⊢ insertNth (succ n✝) x (hd :: tl) = hd :: tl
Theorem: AffineMap.homothety_neg_one_apply
File: Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean

tactic: simp [(homothety_apply), pointReflection_apply _, (neg_vsub_eq_vsub_rev)]
state_before: k : Type ?u.707847
P₁ : Type u_1
P₂ : Type ?u.707853
P₃ : Type ?u.707856
P₄ : Type ?u.707859
V₁ : Type u_2
V₂ : Type ?u.707865
V₃ : Type ?u.707868
V₄ : Type ?u.707871
inst✝¹⁴ : Ring k
inst✝¹³ : AddCommGroup V₁
inst✝¹² : Module k V₁
inst✝¹¹ : AffineSpace V₁ P₁
inst✝¹⁰ : AddCommGroup V₂
inst✝⁹ : Module k V₂
inst✝⁸ : AffineSpace V₂ P₂
inst✝⁷ : AddCommGroup V₃
inst✝⁶ : Module k V₃
inst✝⁵ : AffineSpace V₃ P₃
inst✝⁴ : AddCommGroup V₄
inst✝³ : Module k V₄
inst✝² : AffineSpace V₄ P₄
R' : Type u_3
inst✝¹ : CommRing R'
inst✝ : Module R' V₁
c p : P₁
⊢ ↑(homothety c (-1)) p = ↑(pointReflection R' c) p
Theorem: IntermediateField.bot_eq_top_of_finrank_adjoin_eq_one
File: Mathlib/FieldTheory/Adjoin.lean

tactic: ext y
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α : E
S : Set E
K L : IntermediateField F E
h : ∀ (x : E), finrank F { x_1 // x_1 ∈ F⟮x⟯ } = 1
⊢ ⊥ = ⊤

tactic: rw [iff_true_right IntermediateField.mem_top]
state_before: case h
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α : E
S : Set E
K L : IntermediateField F E
h : ∀ (x : E), finrank F { x_1 // x_1 ∈ F⟮x⟯ } = 1
y : E
⊢ y ∈ ⊥ ↔ y ∈ ⊤

tactic: exact finrank_adjoin_simple_eq_one_iff.mp (h y)
state_before: case h
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α : E
S : Set E
K L : IntermediateField F E
h : ∀ (x : E), finrank F { x_1 // x_1 ∈ F⟮x⟯ } = 1
y : E
⊢ y ∈ ⊥
Theorem: Equiv.Perm.cycleType_mul_inv_mem_cycleFactorsFinset_eq_sub
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

tactic: rw [← (disjoint_mul_inv_of_mem_cycleFactorsFinset hf).cycleType, inv_mul_cancel_right,
  tsub_add_cancel_of_le (cycleType_le_of_mem_cycleFactorsFinset hf)]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
f g : Perm α
hf : f ∈ cycleFactorsFinset g
⊢ cycleType (g * f⁻¹) + cycleType f = cycleType g - cycleType f + cycleType f
Theorem: AffineSubspace.parallel_bot_iff_eq_bot
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: refine' ⟨fun h => _, fun h => h ▸ Parallel.refl _⟩
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
⊢ s ∥ ⊥ ↔ s = ⊥

tactic: rcases h with ⟨v, h⟩
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
h : s ∥ ⊥
⊢ s = ⊥

tactic: rwa [eq_comm, map_eq_bot_iff] at h
state_before: case intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
v : V
h : ⊥ = map (↑(constVAdd k P v)) s
⊢ s = ⊥
Theorem: MeasureTheory.lintegral_mul_const'
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: simp_rw [mul_comm, lintegral_const_mul' r f hr]
state_before: α : Type u_1
β : Type ?u.946443
γ : Type ?u.946446
δ : Type ?u.946449
m : MeasurableSpace α
μ ν : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
hr : r ≠ ⊤
⊢ (∫⁻ (a : α), f a * r ∂μ) = (∫⁻ (a : α), f a ∂μ) * r
Theorem: MeasureTheory.VectorMeasure.AbsolutelyContinuous.map
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: by_cases hf : Measurable f
state_before: α : Type u_2
β : Type u_1
m : MeasurableSpace α
L : Type ?u.642970
M : Type u_3
N : Type u_4
inst✝⁶ : AddCommMonoid L
inst✝⁵ : TopologicalSpace L
inst✝⁴ : AddCommMonoid M
inst✝³ : TopologicalSpace M
inst✝² : AddCommMonoid N
inst✝¹ : TopologicalSpace N
v : VectorMeasure α M
w : VectorMeasure α N
inst✝ : MeasureSpace β
h : v ≪ᵥ w
f : α → β
⊢ VectorMeasure.map v f ≪ᵥ VectorMeasure.map w f

tactic: refine' mk fun s hs hws => _
state_before: case pos
α : Type u_2
β : Type u_1
m : MeasurableSpace α
L : Type ?u.642970
M : Type u_3
N : Type u_4
inst✝⁶ : AddCommMonoid L
inst✝⁵ : TopologicalSpace L
inst✝⁴ : AddCommMonoid M
inst✝³ : TopologicalSpace M
inst✝² : AddCommMonoid N
inst✝¹ : TopologicalSpace N
v : VectorMeasure α M
w : VectorMeasure α N
inst✝ : MeasureSpace β
h : v ≪ᵥ w
f : α → β
hf : Measurable f
⊢ VectorMeasure.map v f ≪ᵥ VectorMeasure.map w f

tactic: rw [map_apply _ hf hs] at hws⊢
state_before: case pos
α : Type u_2
β : Type u_1
m : MeasurableSpace α
L : Type ?u.642970
M : Type u_3
N : Type u_4
inst✝⁶ : AddCommMonoid L
inst✝⁵ : TopologicalSpace L
inst✝⁴ : AddCommMonoid M
inst✝³ : TopologicalSpace M
inst✝² : AddCommMonoid N
inst✝¹ : TopologicalSpace N
v : VectorMeasure α M
w : VectorMeasure α N
inst✝ : MeasureSpace β
h : v ≪ᵥ w
f : α → β
hf : Measurable f
s : Set β
hs : MeasurableSet s
hws : ↑(VectorMeasure.map w f) s = 0
⊢ ↑(VectorMeasure.map v f) s = 0

tactic: exact h hws
state_before: case pos
α : Type u_2
β : Type u_1
m : MeasurableSpace α
L : Type ?u.642970
M : Type u_3
N : Type u_4
inst✝⁶ : AddCommMonoid L
inst✝⁵ : TopologicalSpace L
inst✝⁴ : AddCommMonoid M
inst✝³ : TopologicalSpace M
inst✝² : AddCommMonoid N
inst✝¹ : TopologicalSpace N
v : VectorMeasure α M
w : VectorMeasure α N
inst✝ : MeasureSpace β
h : v ≪ᵥ w
f : α → β
hf : Measurable f
s : Set β
hs : MeasurableSet s
hws : ↑w (f ⁻¹' s) = 0
⊢ ↑v (f ⁻¹' s) = 0

tactic: intro s _
state_before: case neg
α : Type u_2
β : Type u_1
m : MeasurableSpace α
L : Type ?u.642970
M : Type u_3
N : Type u_4
inst✝⁶ : AddCommMonoid L
inst✝⁵ : TopologicalSpace L
inst✝⁴ : AddCommMonoid M
inst✝³ : TopologicalSpace M
inst✝² : AddCommMonoid N
inst✝¹ : TopologicalSpace N
v : VectorMeasure α M
w : VectorMeasure α N
inst✝ : MeasureSpace β
h : v ≪ᵥ w
f : α → β
hf : ¬Measurable f
⊢ VectorMeasure.map v f ≪ᵥ VectorMeasure.map w f

tactic: rw [map_not_measurable v hf, zero_apply]
state_before: case neg
α : Type u_2
β : Type u_1
m : MeasurableSpace α
L : Type ?u.642970
M : Type u_3
N : Type u_4
inst✝⁶ : AddCommMonoid L
inst✝⁵ : TopologicalSpace L
inst✝⁴ : AddCommMonoid M
inst✝³ : TopologicalSpace M
inst✝² : AddCommMonoid N
inst✝¹ : TopologicalSpace N
v : VectorMeasure α M
w : VectorMeasure α N
inst✝ : MeasureSpace β
h : v ≪ᵥ w
f : α → β
hf : ¬Measurable f
s : Set β
a✝ : ↑(VectorMeasure.map w f) s = 0
⊢ ↑(VectorMeasure.map v f) s = 0
Theorem: GroupTopology.continuous_mul'
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: letI := g.toTopologicalSpace
state_before: α : Type u
β : Type v
G : Type w
H : Type x
inst✝ : Group α
g : GroupTopology α
⊢ Continuous fun p => p.fst * p.snd

tactic: haveI := g.toTopologicalGroup
state_before: α : Type u
β : Type v
G : Type w
H : Type x
inst✝ : Group α
g : GroupTopology α
this : TopologicalSpace α := g.toTopologicalSpace
⊢ Continuous fun p => p.fst * p.snd

tactic: exact continuous_mul
state_before: α : Type u
β : Type v
G : Type w
H : Type x
inst✝ : Group α
g : GroupTopology α
this✝ : TopologicalSpace α := g.toTopologicalSpace
this : TopologicalGroup α
⊢ Continuous fun p => p.fst * p.snd
Theorem: Metric.mem_of_closed'
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: simpa only [hs.closure_eq] using @mem_closure_iff _ _ s a
state_before: α : Type u
β : Type v
X : Type ?u.305337
ι : Type ?u.305340
inst✝ : PseudoMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ
s✝ s : Set α
hs : IsClosed s
a : α
⊢ a ∈ s ↔ ∀ (ε : ℝ), ε > 0 → ∃ b, b ∈ s ∧ dist a b < ε