tasksource/leandojo huggingface dataset:
Theorem: Finset.prod_powerset_insert
File: Mathlib/Algebra/BigOperators/Ring.lean

tactic: rw [powerset_insert, Finset.prod_union, Finset.prod_image]
state_before: α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
b : β
f✝ g : α → β
inst✝¹ : DecidableEq α
inst✝ : CommMonoid β
s : Finset α
x : α
h : ¬x ∈ s
f : Finset α → β
⊢ ∏ a in powerset (insert x s), f a = (∏ a in powerset s, f a) * ∏ t in powerset s, f (insert x t)

tactic: intro t₁ h₁ t₂ h₂ heq
state_before: α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
b : β
f✝ g : α → β
inst✝¹ : DecidableEq α
inst✝ : CommMonoid β
s : Finset α
x : α
h : ¬x ∈ s
f : Finset α → β
⊢ ∀ (x_1 : Finset α), x_1 ∈ powerset s → ∀ (y : Finset α), y ∈ powerset s → insert x x_1 = insert x y → x_1 = y

tactic: rw [← Finset.erase_insert (not_mem_of_mem_powerset_of_not_mem h₁ h), ←
  Finset.erase_insert (not_mem_of_mem_powerset_of_not_mem h₂ h), heq]
state_before: α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
b : β
f✝ g : α → β
inst✝¹ : DecidableEq α
inst✝ : CommMonoid β
s : Finset α
x : α
h : ¬x ∈ s
f : Finset α → β
t₁ : Finset α
h₁ : t₁ ∈ powerset s
t₂ : Finset α
h₂ : t₂ ∈ powerset s
heq : insert x t₁ = insert x t₂
⊢ t₁ = t₂

tactic: rw [Finset.disjoint_iff_ne]
state_before: α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
b : β
f✝ g : α → β
inst✝¹ : DecidableEq α
inst✝ : CommMonoid β
s : Finset α
x : α
h : ¬x ∈ s
f : Finset α → β
⊢ Disjoint (powerset s) (image (insert x) (powerset s))

tactic: intro t₁ h₁ t₂ h₂
state_before: α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
b : β
f✝ g : α → β
inst✝¹ : DecidableEq α
inst✝ : CommMonoid β
s : Finset α
x : α
h : ¬x ∈ s
f : Finset α → β
⊢ ∀ (a : Finset α), a ∈ powerset s → ∀ (b : Finset α), b ∈ image (insert x) (powerset s) → a ≠ b

tactic: rcases Finset.mem_image.1 h₂ with ⟨t₃, _h₃, H₃₂⟩
state_before: α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
b : β
f✝ g : α → β
inst✝¹ : DecidableEq α
inst✝ : CommMonoid β
s : Finset α
x : α
h : ¬x ∈ s
f : Finset α → β
t₁ : Finset α
h₁ : t₁ ∈ powerset s
t₂ : Finset α
h₂ : t₂ ∈ image (insert x) (powerset s)
⊢ t₁ ≠ t₂

tactic: rw [← H₃₂]
state_before: case intro.intro
α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
b : β
f✝ g : α → β
inst✝¹ : DecidableEq α
inst✝ : CommMonoid β
s : Finset α
x : α
h : ¬x ∈ s
f : Finset α → β
t₁ : Finset α
h₁ : t₁ ∈ powerset s
t₂ : Finset α
h₂ : t₂ ∈ image (insert x) (powerset s)
t₃ : Finset α
_h₃ : t₃ ∈ powerset s
H₃₂ : insert x t₃ = t₂
⊢ t₁ ≠ t₂

tactic: exact ne_insert_of_not_mem _ _ (not_mem_of_mem_powerset_of_not_mem h₁ h)
state_before: case intro.intro
α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
b : β
f✝ g : α → β
inst✝¹ : DecidableEq α
inst✝ : CommMonoid β
s : Finset α
x : α
h : ¬x ∈ s
f : Finset α → β
t₁ : Finset α
h₁ : t₁ ∈ powerset s
t₂ : Finset α
h₂ : t₂ ∈ image (insert x) (powerset s)
t₃ : Finset α
_h₃ : t₃ ∈ powerset s
H₃₂ : insert x t₃ = t₂
⊢ t₁ ≠ insert x t₃
Theorem: MeasureTheory.VectorMeasure.ext_iff
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: constructor
state_before: α : Type u_1
β : Type ?u.8146
m : MeasurableSpace α
M : Type u_2
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v w : VectorMeasure α M
⊢ v = w ↔ ∀ (i : Set α), MeasurableSet i → ↑v i = ↑w i

tactic: rintro rfl _ _
state_before: case mp
α : Type u_1
β : Type ?u.8146
m : MeasurableSpace α
M : Type u_2
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v w : VectorMeasure α M
⊢ v = w → ∀ (i : Set α), MeasurableSet i → ↑v i = ↑w i

tactic: rfl
state_before: case mp
α : Type u_1
β : Type ?u.8146
m : MeasurableSpace α
M : Type u_2
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v : VectorMeasure α M
i✝ : Set α
a✝ : MeasurableSet i✝
⊢ ↑v i✝ = ↑v i✝

tactic: rw [ext_iff']
state_before: case mpr
α : Type u_1
β : Type ?u.8146
m : MeasurableSpace α
M : Type u_2
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v w : VectorMeasure α M
⊢ (∀ (i : Set α), MeasurableSet i → ↑v i = ↑w i) → v = w

tactic: intro h i
state_before: case mpr
α : Type u_1
β : Type ?u.8146
m : MeasurableSpace α
M : Type u_2
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v w : VectorMeasure α M
⊢ (∀ (i : Set α), MeasurableSet i → ↑v i = ↑w i) → ∀ (i : Set α), ↑v i = ↑w i

tactic: by_cases hi : MeasurableSet i
state_before: case mpr
α : Type u_1
β : Type ?u.8146
m : MeasurableSpace α
M : Type u_2
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v w : VectorMeasure α M
h : ∀ (i : Set α), MeasurableSet i → ↑v i = ↑w i
i : Set α
⊢ ↑v i = ↑w i

tactic: exact h i hi
state_before: case pos
α : Type u_1
β : Type ?u.8146
m : MeasurableSpace α
M : Type u_2
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v w : VectorMeasure α M
h : ∀ (i : Set α), MeasurableSet i → ↑v i = ↑w i
i : Set α
hi : MeasurableSet i
⊢ ↑v i = ↑w i

tactic: simp_rw [not_measurable _ hi]
state_before: case neg
α : Type u_1
β : Type ?u.8146
m : MeasurableSpace α
M : Type u_2
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v w : VectorMeasure α M
h : ∀ (i : Set α), MeasurableSet i → ↑v i = ↑w i
i : Set α
hi : ¬MeasurableSet i
⊢ ↑v i = ↑w i
Theorem: Left.mul_nonneg
File: Mathlib/Algebra/Order/Ring/Lemmas.lean

tactic: simpa only [mul_zero] using mul_le_mul_of_nonneg_left hb ha
state_before: α : Type u_1
a b c d : α
inst✝² : MulZeroClass α
inst✝¹ : Preorder α
inst✝ : PosMulMono α
ha : 0 ≤ a
hb : 0 ≤ b
⊢ 0 ≤ a * b
Theorem: MonoidHom.eq_liftOfRightInverse
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: simp_rw [← hh]
state_before: G : Type ?u.666706
G' : Type ?u.666709
inst✝⁵ : Group G
inst✝⁴ : Group G'
A : Type ?u.666718
inst✝³ : AddGroup A
G₁ : Type u_1
G₂ : Type u_2
G₃ : Type u_3
inst✝² : Group G₁
inst✝¹ : Group G₂
inst✝ : Group G₃
f : G₁ →* G₂
f_inv : G₂ → G₁
hf : Function.RightInverse f_inv ↑f
g : G₁ →* G₃
hg : ker f ≤ ker g
h : G₂ →* G₃
hh : comp h f = g
⊢ h = ↑(liftOfRightInverse f f_inv hf) { val := g, property := hg }

tactic: exact ((f.liftOfRightInverse f_inv hf).apply_symm_apply _).symm
state_before: G : Type ?u.666706
G' : Type ?u.666709
inst✝⁵ : Group G
inst✝⁴ : Group G'
A : Type ?u.666718
inst✝³ : AddGroup A
G₁ : Type u_1
G₂ : Type u_2
G₃ : Type u_3
inst✝² : Group G₁
inst✝¹ : Group G₂
inst✝ : Group G₃
f : G₁ →* G₂
f_inv : G₂ → G₁
hf : Function.RightInverse f_inv ↑f
g : G₁ →* G₃
hg : ker f ≤ ker g
h : G₂ →* G₃
hh : comp h f = g
⊢ h = ↑(liftOfRightInverse f f_inv hf) { val := comp h f, property := (_ : (fun g => ker f ≤ ker g) (comp h f)) }
Theorem: Relation.iff_comp
File: Mathlib/Logic/Relation.lean

tactic: rw [this, eq_comp]
state_before: α : Type u_1
β : Type ?u.11101
γ : Type ?u.11104
δ : Type ?u.11107
r✝ : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
r : Prop → α → Prop
this : (fun x x_1 => x ↔ x_1) = fun x x_1 => x = x_1
⊢ (fun x x_1 => x ↔ x_1) ∘r r = r

tactic: funext a b
state_before: α : Type u_1
β : Type ?u.11101
γ : Type ?u.11104
δ : Type ?u.11107
r✝ : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
r : Prop → α → Prop
⊢ (fun x x_1 => x ↔ x_1) = fun x x_1 => x = x_1

tactic: exact iff_eq_eq
state_before: case h.h
α : Type u_1
β : Type ?u.11101
γ : Type ?u.11104
δ : Type ?u.11107
r✝ : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
r : Prop → α → Prop
a b : Prop
⊢ (a ↔ b) = (a = b)
Theorem: irrational_mul_int_iff
File: Mathlib/Data/Real/Irrational.lean

tactic: rw [← cast_coe_int, irrational_mul_rat_iff, Int.cast_ne_zero]
state_before: q : ℚ
m : ℤ
n : ℕ
x : ℝ
⊢ Irrational (x * ↑m) ↔ m ≠ 0 ∧ Irrational x
Theorem: expMapCircle_add
File: Mathlib/Analysis/Complex/Circle.lean

tactic: simp only [expMapCircle_apply, Submonoid.coe_mul, ofReal_add, add_mul, Complex.exp_add]
state_before: x y : ℝ
⊢ ↑(↑expMapCircle (x + y)) = ↑(↑expMapCircle x * ↑expMapCircle y)
Theorem: Std.RBNode.balance1_toList
File: Std/Data/RBMap/Lemmas.lean

tactic: unfold balance1
state_before: α : Type u_1
l : RBNode α
v : α
r : RBNode α
⊢ toList (balance1 l v r) = toList l ++ v :: toList r

tactic: split <;> simp
state_before: α : Type u_1
l : RBNode α
v : α
r : RBNode α
⊢ toList
      (match l, v, r with
      | node red (node red a x b) y c, z, d => node red (node black a x b) y (node black c z d)
      | node red a x (node red b y c), z, d => node red (node black a x b) y (node black c z d)
      | a, x, b => node black a x b) =
    toList l ++ v :: toList r
Theorem: toIocMod_sub_zsmul
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [sub_eq_add_neg, ← neg_smul, toIocMod_add_zsmul]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
m : ℤ
⊢ toIocMod hp a (b - m • p) = toIocMod hp a b
Theorem: MonoidHom.map_mrange
File: Mathlib/GroupTheory/Submonoid/Operations.lean

tactic: simpa only [mrange_eq_map] using (⊤ : Submonoid M).map_map g f
state_before: M : Type u_3
N : Type u_1
P : Type u_2
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type ?u.117566
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
F : Type ?u.117590
mc : MonoidHomClass F M N
g : N →* P
f : M →* N
⊢ map g (mrange f) = mrange (comp g f)
Theorem: Fin.append_right_nil
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: rw [hv, add_zero]
state_before: m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ (succ i)
i : Fin n
y : α✝ (succ i)
z : α✝ 0
α : Type ?u.31388
u : Fin m → α
v : Fin n → α
hv : n = 0
⊢ m + n = m

tactic: refine' funext (Fin.addCases (fun l => _) fun r => _)
state_before: m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ (succ i)
i : Fin n
y : α✝ (succ i)
z : α✝ 0
α : Type u_1
u : Fin m → α
v : Fin n → α
hv : n = 0
⊢ append u v = u ∘ ↑(cast (_ : m + n = m))

tactic: rw [append_left, Function.comp_apply]
state_before: case refine'_1
m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ (succ i)
i : Fin n
y : α✝ (succ i)
z : α✝ 0
α : Type u_1
u : Fin m → α
v : Fin n → α
hv : n = 0
l : Fin m
⊢ append u v (↑(castAdd n) l) = (u ∘ ↑(cast (_ : m + n = m))) (↑(castAdd n) l)

tactic: refine' congr_arg u (Fin.ext _)
state_before: case refine'_1
m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ (succ i)
i : Fin n
y : α✝ (succ i)
z : α✝ 0
α : Type u_1
u : Fin m → α
v : Fin n → α
hv : n = 0
l : Fin m
⊢ u l = u (↑(cast (_ : m + n = m)) (↑(castAdd n) l))

tactic: simp
state_before: case refine'_1
m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ (succ i)
i : Fin n
y : α✝ (succ i)
z : α✝ 0
α : Type u_1
u : Fin m → α
v : Fin n → α
hv : n = 0
l : Fin m
⊢ ↑l = ↑(↑(cast (_ : m + n = m)) (↑(castAdd n) l))

tactic: exact (Fin.cast hv r).elim0'
state_before: case refine'_2
m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ (succ i)
i : Fin n
y : α✝ (succ i)
z : α✝ 0
α : Type u_1
u : Fin m → α
v : Fin n → α
hv : n = 0
r : Fin n
⊢ append u v (↑(natAdd m) r) = (u ∘ ↑(cast (_ : m + n = m))) (↑(natAdd m) r)
Theorem: MeasureTheory.Measure.univ_pi_Ioo_ae_eq_Icc
File: Mathlib/MeasureTheory/Constructions/Pi.lean

tactic: rw [← pi_univ_Icc]
state_before: ι : Type u_2
ι' : Type ?u.4246959
α : ι → Type u_1
inst✝⁴ : Fintype ι
m : (i : ι) → OuterMeasure (α i)
inst✝³ : (i : ι) → MeasurableSpace (α i)
μ : (i : ι) → Measure (α i)
inst✝² : ∀ (i : ι), SigmaFinite (μ i)
inst✝¹ : (i : ι) → PartialOrder (α i)
inst✝ : ∀ (i : ι), NoAtoms (μ i)
f g : (i : ι) → α i
⊢ (Set.pi univ fun i => Ioo (f i) (g i)) =ᶠ[ae (Measure.pi μ)] Icc f g

tactic: exact pi_Ioo_ae_eq_pi_Icc
state_before: ι : Type u_2
ι' : Type ?u.4246959
α : ι → Type u_1
inst✝⁴ : Fintype ι
m : (i : ι) → OuterMeasure (α i)
inst✝³ : (i : ι) → MeasurableSpace (α i)
μ : (i : ι) → Measure (α i)
inst✝² : ∀ (i : ι), SigmaFinite (μ i)
inst✝¹ : (i : ι) → PartialOrder (α i)
inst✝ : ∀ (i : ι), NoAtoms (μ i)
f g : (i : ι) → α i
⊢ (Set.pi univ fun i => Ioo (f i) (g i)) =ᶠ[ae (Measure.pi μ)] Set.pi univ fun i => Icc (f i) (g i)
Theorem: Nat.dvd_of_mul_dvd_mul_right
File: Std/Data/Nat/Lemmas.lean

tactic: rw [Nat.mul_comm m k, Nat.mul_comm n k] at H
state_before: k m n : Nat
kpos : 0 < k
H : m * k ∣ n * k
⊢ m ∣ n

tactic: exact Nat.dvd_of_mul_dvd_mul_left kpos H
state_before: k m n : Nat
kpos : 0 < k
H : k * m ∣ k * n
⊢ m ∣ n
Theorem: IsPrimitiveRoot.nthRoots_one_eq_biUnion_primitiveRoots
File: Mathlib/RingTheory/RootsOfUnity/Basic.lean

tactic: by_cases hn : n = 0
state_before: M : Type ?u.3642802
N : Type ?u.3642805
G : Type ?u.3642808
R : Type u_1
S : Type ?u.3642814
F : Type ?u.3642817
inst✝⁴ : CommMonoid M
inst✝³ : CommMonoid N
inst✝² : DivisionCommMonoid G
k l : ℕ
inst✝¹ : CommRing R
ζ✝ : Rˣ
h✝ : IsPrimitiveRoot ζ✝ k
inst✝ : IsDomain R
ζ : R
n : ℕ
h : IsPrimitiveRoot ζ n
⊢ nthRootsFinset n R = Finset.biUnion (Nat.divisors n) fun i => primitiveRoots i R

tactic: exact nthRoots_one_eq_biUnion_primitiveRoots' (n := ⟨n, Nat.pos_of_ne_zero hn⟩) h
state_before: case neg
M : Type ?u.3642802
N : Type ?u.3642805
G : Type ?u.3642808
R : Type u_1
S : Type ?u.3642814
F : Type ?u.3642817
inst✝⁴ : CommMonoid M
inst✝³ : CommMonoid N
inst✝² : DivisionCommMonoid G
k l : ℕ
inst✝¹ : CommRing R
ζ✝ : Rˣ
h✝ : IsPrimitiveRoot ζ✝ k
inst✝ : IsDomain R
ζ : R
n : ℕ
h : IsPrimitiveRoot ζ n
hn : ¬n = 0
⊢ nthRootsFinset n R = Finset.biUnion (Nat.divisors n) fun i => primitiveRoots i R

tactic: simp [hn]
state_before: case pos
M : Type ?u.3642802
N : Type ?u.3642805
G : Type ?u.3642808
R : Type u_1
S : Type ?u.3642814
F : Type ?u.3642817
inst✝⁴ : CommMonoid M
inst✝³ : CommMonoid N
inst✝² : DivisionCommMonoid G
k l : ℕ
inst✝¹ : CommRing R
ζ✝ : Rˣ
h✝ : IsPrimitiveRoot ζ✝ k
inst✝ : IsDomain R
ζ : R
n : ℕ
h : IsPrimitiveRoot ζ n
hn : n = 0
⊢ nthRootsFinset n R = Finset.biUnion (Nat.divisors n) fun i => primitiveRoots i R
Theorem: BoxIntegral.Prepartition.iUnion_biUnion
File: Mathlib/Analysis/BoxIntegral/Partition/Basic.lean

tactic: simp [Prepartition.iUnion]
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi✝ πi₁ πi₂ πi : (J : Box ι) → Prepartition J
⊢ Prepartition.iUnion (biUnion π πi) = ⋃ (J : Box ι) (_ : J ∈ π), Prepartition.iUnion (πi J)
Theorem: MonoidAlgebra.of_mem_span_of_iff
File: Mathlib/RingTheory/FiniteType.lean

tactic: refine' ⟨fun h => _, fun h => Submodule.subset_span <| Set.mem_image_of_mem (of R M) h⟩
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : CommMonoid M
inst✝ : Nontrivial R
m : M
S : Set M
⊢ ↑(of R M) m ∈ span R (↑(of R M) '' S) ↔ m ∈ S

tactic: erw [of, MonoidHom.coe_mk, ← Finsupp.supported_eq_span_single, Finsupp.mem_supported,
  Finsupp.support_single_ne_zero _ (one_ne_zero' R)] at h
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : CommMonoid M
inst✝ : Nontrivial R
m : M
S : Set M
h : ↑(of R M) m ∈ span R (↑(of R M) '' S)
⊢ m ∈ S

tactic: simpa using h
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : CommMonoid M
inst✝ : Nontrivial R
m : M
S : Set M
h : ↑{m} ⊆ S
⊢ m ∈ S
Theorem: SimpleGraph.Walk.getVert_zero
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: cases w <;> rfl
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
w : Walk G u v
⊢ getVert w 0 = u
Theorem: MeasureTheory.snorm'_zero'
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: cases' le_or_lt 0 q with hq0 hq_neg
state_before: α : Type u_1
E : Type ?u.915301
F : Type u_2
G : Type ?u.915307
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hq0_ne : q ≠ 0
hμ : μ ≠ 0
⊢ snorm' 0 q μ = 0

tactic: exact snorm'_zero (lt_of_le_of_ne hq0 hq0_ne.symm)
state_before: case inl
α : Type u_1
E : Type ?u.915301
F : Type u_2
G : Type ?u.915307
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hq0_ne : q ≠ 0
hμ : μ ≠ 0
hq0 : 0 ≤ q
⊢ snorm' 0 q μ = 0

tactic: simp [snorm', ENNReal.rpow_eq_zero_iff, hμ, hq_neg]
state_before: case inr
α : Type u_1
E : Type ?u.915301
F : Type u_2
G : Type ?u.915307
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hq0_ne : q ≠ 0
hμ : μ ≠ 0
hq_neg : q < 0
⊢ snorm' 0 q μ = 0
Theorem: Subgroup.mem_leftTransversals_iff_existsUnique_inv_mul_mem
File: Mathlib/GroupTheory/Complement.lean

tactic: rw [leftTransversals, Set.mem_setOf_eq, isComplement_iff_existsUnique]
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
⊢ S ∈ leftTransversals T ↔ ∀ (g : G), ∃! s, (↑s)⁻¹ * g ∈ T

tactic: refine' ⟨fun h g => _, fun h g => _⟩
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
⊢ (∀ (g : G), ∃! x, ↑x.fst * ↑x.snd = g) ↔ ∀ (g : G), ∃! s, (↑s)⁻¹ * g ∈ T

tactic: obtain ⟨x, h1, h2⟩ := h g
state_before: case refine'_1
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
h : ∀ (g : G), ∃! x, ↑x.fst * ↑x.snd = g
g : G
⊢ ∃! s, (↑s)⁻¹ * g ∈ T

tactic: obtain ⟨x, h1, h2⟩ := h g
state_before: case refine'_2
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
h : ∀ (g : G), ∃! s, (↑s)⁻¹ * g ∈ T
g : G
⊢ ∃! x, ↑x.fst * ↑x.snd = g

tactic: refine' ⟨⟨x, (↑x)⁻¹ * g, h1⟩, mul_inv_cancel_left (↑x) g, fun y hy => _⟩
state_before: case refine'_2.intro.intro
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
h : ∀ (g : G), ∃! s, (↑s)⁻¹ * g ∈ T
g : G
x : ↑S
h1 : (↑x)⁻¹ * g ∈ T
h2 : ∀ (y : ↑S), (fun s => (↑s)⁻¹ * g ∈ T) y → y = x
⊢ ∃! x, ↑x.fst * ↑x.snd = g

tactic: exact Prod.ext hf (Subtype.ext (eq_inv_mul_of_mul_eq (hf ▸ hy)))
state_before: case refine'_2.intro.intro
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
h : ∀ (g : G), ∃! s, (↑s)⁻¹ * g ∈ T
g : G
x : ↑S
h1 : (↑x)⁻¹ * g ∈ T
h2 : ∀ (y : ↑S), (fun s => (↑s)⁻¹ * g ∈ T) y → y = x
y : ↑S × ↑T
hy : (fun x => ↑x.fst * ↑x.snd = g) y
hf : y.fst = x
⊢ y = (x, { val := (↑x)⁻¹ * g, property := h1 })
Theorem: EReal.tendsto_toReal
File: Mathlib/Topology/Instances/EReal.lean

tactic: lift a to ℝ using ⟨ha, h'a⟩
state_before: α : Type ?u.4599
inst✝ : TopologicalSpace α
a : EReal
ha : a ≠ ⊤
h'a : a ≠ ⊥
⊢ Tendsto toReal (𝓝 a) (𝓝 (toReal a))

tactic: rw [nhds_coe, tendsto_map'_iff]
state_before: case intro
α : Type ?u.4599
inst✝ : TopologicalSpace α
a : ℝ
ha : ↑a ≠ ⊤
h'a : ↑a ≠ ⊥
⊢ Tendsto toReal (𝓝 ↑a) (𝓝 (toReal ↑a))

tactic: exact tendsto_id
state_before: case intro
α : Type ?u.4599
inst✝ : TopologicalSpace α
a : ℝ
ha : ↑a ≠ ⊤
h'a : ↑a ≠ ⊥
⊢ Tendsto (toReal ∘ Real.toEReal) (𝓝 a) (𝓝 (toReal ↑a))
Theorem: CategoryTheory.Limits.prod.map_id_id
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: apply prod.hom_ext
state_before: C : Type u
inst✝¹ : Category C
X✝ Y✝ X Y : C
inst✝ : HasBinaryProduct X Y
⊢ map (𝟙 X) (𝟙 Y) = 𝟙 (X ⨯ Y)

tactic: simp
state_before: case h₁
C : Type u
inst✝¹ : Category C
X✝ Y✝ X Y : C
inst✝ : HasBinaryProduct X Y
⊢ map (𝟙 X) (𝟙 Y) ≫ fst = 𝟙 (X ⨯ Y) ≫ fst

case h₂
C : Type u
inst✝¹ : Category C
X✝ Y✝ X Y : C
inst✝ : HasBinaryProduct X Y
⊢ map (𝟙 X) (𝟙 Y) ≫ snd = 𝟙 (X ⨯ Y) ≫ snd

tactic: simp
state_before: case h₂
C : Type u
inst✝¹ : Category C
X✝ Y✝ X Y : C
inst✝ : HasBinaryProduct X Y
⊢ map (𝟙 X) (𝟙 Y) ≫ snd = 𝟙 (X ⨯ Y) ≫ snd
Theorem: Complex.mul_I_re
File: Mathlib/Data/Complex/Basic.lean

tactic: simp
state_before: z : ℂ
⊢ (z * I).re = -z.im
Theorem: Urysohns.CU.approx_of_mem_C
File: Mathlib/Topology/UrysohnsLemma.lean

tactic: induction' n with n ihn generalizing c
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
c : CU X
n : ℕ
x : X
hx : x ∈ c.C
⊢ approx n c x = 0

tactic: exact indicator_of_not_mem (fun (hU : x ∈ c.Uᶜ) => hU <| c.subset hx) _
state_before: case zero
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
c✝ : CU X
x : X
hx✝ : x ∈ c✝.C
c : CU X
hx : x ∈ c.C
⊢ approx Nat.zero c x = 0

tactic: simp only [approx]
state_before: case succ
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
c✝ : CU X
x : X
hx✝ : x ∈ c✝.C
n : ℕ
ihn : ∀ (c : CU X), x ∈ c.C → approx n c x = 0
c : CU X
hx : x ∈ c.C
⊢ approx (Nat.succ n) c x = 0

tactic: rw [ihn, ihn, midpoint_self]
state_before: case succ
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
c✝ : CU X
x : X
hx✝ : x ∈ c✝.C
n : ℕ
ihn : ∀ (c : CU X), x ∈ c.C → approx n c x = 0
c : CU X
hx : x ∈ c.C
⊢ midpoint ℝ (approx n (left c) x) (approx n (right c) x) = 0

tactic: exacts [c.subset_right_C hx, hx]
state_before: case succ.hx
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
c✝ : CU X
x : X
hx✝ : x ∈ c✝.C
n : ℕ
ihn : ∀ (c : CU X), x ∈ c.C → approx n c x = 0
c : CU X
hx : x ∈ c.C
⊢ x ∈ (right c).C

case succ.hx
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
c✝ : CU X
x : X
hx✝ : x ∈ c✝.C
n : ℕ
ihn : ∀ (c : CU X), x ∈ c.C → approx n c x = 0
c : CU X
hx : x ∈ c.C
⊢ x ∈ (left c).C
Theorem: LiouvilleWith.neg
File: Mathlib/NumberTheory/Liouville/LiouvilleWith.lean

tactic: rcases h with ⟨C, hC⟩
state_before: p q x y : ℝ
r : ℚ
m : ℤ
n : ℕ
h : LiouvilleWith p x
⊢ LiouvilleWith p (-x)

tactic: refine ⟨C, hC.mono ?_⟩
state_before: case intro
p q x y : ℝ
r : ℚ
m : ℤ
n : ℕ
C : ℝ
hC : ∃ᶠ (n : ℕ) in atTop, ∃ m, x ≠ ↑m / ↑n ∧ abs (x - ↑m / ↑n) < C / ↑n ^ p
⊢ LiouvilleWith p (-x)

tactic: rintro n ⟨m, hne, hlt⟩
state_before: case intro
p q x y : ℝ
r : ℚ
m : ℤ
n : ℕ
C : ℝ
hC : ∃ᶠ (n : ℕ) in atTop, ∃ m, x ≠ ↑m / ↑n ∧ abs (x - ↑m / ↑n) < C / ↑n ^ p
⊢ ∀ (x_1 : ℕ),
    (∃ m, x ≠ ↑m / ↑x_1 ∧ abs (x - ↑m / ↑x_1) < C / ↑x_1 ^ p) →
      ∃ m, -x ≠ ↑m / ↑x_1 ∧ abs (-x - ↑m / ↑x_1) < C / ↑x_1 ^ p

tactic: refine ⟨-m, by simp [neg_div, hne], ?_⟩
state_before: case intro.intro.intro
p q x y : ℝ
r : ℚ
m✝ : ℤ
n✝ : ℕ
C : ℝ
hC : ∃ᶠ (n : ℕ) in atTop, ∃ m, x ≠ ↑m / ↑n ∧ abs (x - ↑m / ↑n) < C / ↑n ^ p
n : ℕ
m : ℤ
hne : x ≠ ↑m / ↑n
hlt : abs (x - ↑m / ↑n) < C / ↑n ^ p
⊢ ∃ m, -x ≠ ↑m / ↑n ∧ abs (-x - ↑m / ↑n) < C / ↑n ^ p

tactic: simp [neg_div, hne]
state_before: p q x y : ℝ
r : ℚ
m✝ : ℤ
n✝ : ℕ
C : ℝ
hC : ∃ᶠ (n : ℕ) in atTop, ∃ m, x ≠ ↑m / ↑n ∧ abs (x - ↑m / ↑n) < C / ↑n ^ p
n : ℕ
m : ℤ
hne : x ≠ ↑m / ↑n
hlt : abs (x - ↑m / ↑n) < C / ↑n ^ p
⊢ -x ≠ ↑(-m) / ↑n

tactic: convert hlt using 1
state_before: case intro.intro.intro
p q x y : ℝ
r : ℚ
m✝ : ℤ
n✝ : ℕ
C : ℝ
hC : ∃ᶠ (n : ℕ) in atTop, ∃ m, x ≠ ↑m / ↑n ∧ abs (x - ↑m / ↑n) < C / ↑n ^ p
n : ℕ
m : ℤ
hne : x ≠ ↑m / ↑n
hlt : abs (x - ↑m / ↑n) < C / ↑n ^ p
⊢ abs (-x - ↑(-m) / ↑n) < C / ↑n ^ p

tactic: rw [abs_sub_comm]
state_before: case h.e'_3
p q x y : ℝ
r : ℚ
m✝ : ℤ
n✝ : ℕ
C : ℝ
hC : ∃ᶠ (n : ℕ) in atTop, ∃ m, x ≠ ↑m / ↑n ∧ abs (x - ↑m / ↑n) < C / ↑n ^ p
n : ℕ
m : ℤ
hne : x ≠ ↑m / ↑n
hlt : abs (x - ↑m / ↑n) < C / ↑n ^ p
⊢ abs (-x - ↑(-m) / ↑n) = abs (x - ↑m / ↑n)

tactic: congr! 1
state_before: case h.e'_3
p q x y : ℝ
r : ℚ
m✝ : ℤ
n✝ : ℕ
C : ℝ
hC : ∃ᶠ (n : ℕ) in atTop, ∃ m, x ≠ ↑m / ↑n ∧ abs (x - ↑m / ↑n) < C / ↑n ^ p
n : ℕ
m : ℤ
hne : x ≠ ↑m / ↑n
hlt : abs (x - ↑m / ↑n) < C / ↑n ^ p
⊢ abs (↑(-m) / ↑n - -x) = abs (x - ↑m / ↑n)

tactic: push_cast
state_before: case h.e'_3.h.e'_3
p q x y : ℝ
r : ℚ
m✝ : ℤ
n✝ : ℕ
C : ℝ
hC : ∃ᶠ (n : ℕ) in atTop, ∃ m, x ≠ ↑m / ↑n ∧ abs (x - ↑m / ↑n) < C / ↑n ^ p
n : ℕ
m : ℤ
hne : x ≠ ↑m / ↑n
hlt : abs (x - ↑m / ↑n) < C / ↑n ^ p
⊢ ↑(-m) / ↑n - -x = x - ↑m / ↑n

tactic: ring
state_before: case h.e'_3.h.e'_3
p q x y : ℝ
r : ℚ
m✝ : ℤ
n✝ : ℕ
C : ℝ
hC : ∃ᶠ (n : ℕ) in atTop, ∃ m, x ≠ ↑m / ↑n ∧ abs (x - ↑m / ↑n) < C / ↑n ^ p
n : ℕ
m : ℤ
hne : x ≠ ↑m / ↑n
hlt : abs (x - ↑m / ↑n) < C / ↑n ^ p
⊢ -↑m / ↑n - -x = x - ↑m / ↑n