tasksource/leandojo huggingface dataset:
Theorem: Units.divp_add_divp
File: Mathlib/Algebra/Ring/Units.lean

tactic: simp only [divp, add_mul, mul_inv_rev, val_mul]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : CommRing α
a b : α
u₁ u₂ : αˣ
⊢ a /ₚ u₁ + b /ₚ u₂ = (a * ↑u₂ + ↑u₁ * b) /ₚ (u₁ * u₂)

tactic: rw [mul_comm (↑u₁ * b), mul_comm b]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : CommRing α
a b : α
u₁ u₂ : αˣ
⊢ a * ↑u₁⁻¹ + b * ↑u₂⁻¹ = a * ↑u₂ * (↑u₂⁻¹ * ↑u₁⁻¹) + ↑u₁ * b * (↑u₂⁻¹ * ↑u₁⁻¹)

tactic: rw [←mul_assoc, ←mul_assoc, mul_assoc a, mul_assoc (↑u₂⁻¹ : α), mul_inv, inv_mul, mul_one,
  mul_one]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : CommRing α
a b : α
u₁ u₂ : αˣ
⊢ a * ↑u₁⁻¹ + ↑u₂⁻¹ * b = a * ↑u₂ * (↑u₂⁻¹ * ↑u₁⁻¹) + ↑u₂⁻¹ * ↑u₁⁻¹ * (↑u₁ * b)
Theorem: Matrix.conjTranspose_conjTranspose
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp
state_before: l : Type ?u.952495
m : Type u_1
n : Type u_2
o : Type ?u.952504
m' : o → Type ?u.952509
n' : o → Type ?u.952514
R : Type ?u.952517
S : Type ?u.952520
α : Type v
β : Type w
γ : Type ?u.952527
inst✝ : InvolutiveStar α
M : Matrix m n α
⊢ ∀ (i : m) (j : n), Mᴴᴴ i j = M i j
Theorem: List.any_eq_true
File: Std/Data/List/Lemmas.lean

tactic: induction l <;> simp [*]
state_before: α : Type u_1
p : α → Bool
l : List α
⊢ any l p = true ↔ ∃ x, x ∈ l ∧ p x = true
Theorem: FirstOrder.Language.Hom.realize_term
File: Mathlib/ModelTheory/Semantics.lean

tactic: induction t
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type ?u.26756
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
g : M →[L] N
t : Term L α
v : α → M
⊢ Term.realize (↑g ∘ v) t = ↑g (Term.realize v t)

tactic: rfl
state_before: case var
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type ?u.26756
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
g : M →[L] N
v : α → M
_a✝ : α
⊢ Term.realize (↑g ∘ v) (var _a✝) = ↑g (Term.realize v (var _a✝))

tactic: rw [Term.realize, Term.realize, g.map_fun]
state_before: case func
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type ?u.26756
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
g : M →[L] N
v : α → M
l✝ : ℕ
_f✝ : Functions L l✝
_ts✝ : Fin l✝ → Term L α
_ts_ih✝ : ∀ (a : Fin l✝), Term.realize (↑g ∘ v) (_ts✝ a) = ↑g (Term.realize v (_ts✝ a))
⊢ Term.realize (↑g ∘ v) (func _f✝ _ts✝) = ↑g (Term.realize v (func _f✝ _ts✝))

tactic: refine' congr rfl _
state_before: case func
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type ?u.26756
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
g : M →[L] N
v : α → M
l✝ : ℕ
_f✝ : Functions L l✝
_ts✝ : Fin l✝ → Term L α
_ts_ih✝ : ∀ (a : Fin l✝), Term.realize (↑g ∘ v) (_ts✝ a) = ↑g (Term.realize v (_ts✝ a))
⊢ (funMap _f✝ fun i => Term.realize (↑g ∘ v) (_ts✝ i)) = funMap _f✝ (↑g ∘ fun i => Term.realize v (_ts✝ i))

tactic: ext x
state_before: case func
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type ?u.26756
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
g : M →[L] N
v : α → M
l✝ : ℕ
_f✝ : Functions L l✝
_ts✝ : Fin l✝ → Term L α
_ts_ih✝ : ∀ (a : Fin l✝), Term.realize (↑g ∘ v) (_ts✝ a) = ↑g (Term.realize v (_ts✝ a))
⊢ (fun i => Term.realize (↑g ∘ v) (_ts✝ i)) = ↑g ∘ fun i => Term.realize v (_ts✝ i)

tactic: simp [*]
state_before: case func.h
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type ?u.26756
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
g : M →[L] N
v : α → M
l✝ : ℕ
_f✝ : Functions L l✝
_ts✝ : Fin l✝ → Term L α
_ts_ih✝ : ∀ (a : Fin l✝), Term.realize (↑g ∘ v) (_ts✝ a) = ↑g (Term.realize v (_ts✝ a))
x : Fin l✝
⊢ Term.realize (↑g ∘ v) (_ts✝ x) = (↑g ∘ fun i => Term.realize v (_ts✝ i)) x
Theorem: Function.LeftInverse.map_nhds_eq
File: Mathlib/Topology/ContinuousOn.lean

tactic: simpa only [nhdsWithin_univ, image_univ] using
  (h.leftInvOn univ).map_nhdsWithin_eq (h x) (by rwa [image_univ]) hg.continuousWithinAt
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.339400
δ : Type ?u.339403
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
g : β → α
x : β
h : LeftInverse f g
hf : ContinuousWithinAt f (range g) (g x)
hg : ContinuousAt g x
⊢ map g (𝓝 x) = 𝓝[range g] g x

tactic: rwa [image_univ]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.339400
δ : Type ?u.339403
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
g : β → α
x : β
h : LeftInverse f g
hf : ContinuousWithinAt f (range g) (g x)
hg : ContinuousAt g x
⊢ ContinuousWithinAt f (g '' univ) (g x)
Theorem: Asymptotics.IsTheta.tendsto_zero_iff
File: Mathlib/Analysis/Asymptotics/Theta.lean

tactic: simp only [← isLittleO_one_iff ℝ, h.isLittleO_congr_left]
state_before: α : Type u_1
β : Type ?u.32664
E : Type ?u.32667
F : Type ?u.32670
G : Type ?u.32673
E' : Type ?u.32676
F' : Type ?u.32679
G' : Type ?u.32682
E'' : Type u_2
F'' : Type u_3
G'' : Type ?u.32691
R : Type ?u.32694
R' : Type ?u.32697
𝕜 : Type ?u.32700
𝕜' : Type ?u.32703
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
l l' : Filter α
h : f'' =Θ[l] g''
⊢ Tendsto f'' l (𝓝 0) ↔ Tendsto g'' l (𝓝 0)
Theorem: sdiff_sdiff_left'
File: Mathlib/Order/BooleanAlgebra.lean

tactic: rw [sdiff_sdiff_left, sdiff_sup]
state_before: α : Type u
β : Type ?u.30911
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ (x \ y) \ z = x \ y ⊓ x \ z
Theorem: Mathlib.Meta.NormNum.isNat_minFac_4
File: Mathlib/Tactic/NormNum/Prime.lean

tactic: refine ⟨(Nat.prime_def_minFac.mp ?_).2⟩
state_before: n k : ℕ
h1 : MinFacHelper n k
h2 : ble (k * k) n = false
⊢ IsNat (minFac n) n

tactic: rw [Nat.prime_def_le_sqrt]
state_before: n k : ℕ
h1 : MinFacHelper n k
h2 : ble (k * k) n = false
⊢ Nat.Prime n

tactic: refine ⟨h1.one_lt, λ m hm hmn h2mn ↦ ?_⟩
state_before: n k : ℕ
h1 : MinFacHelper n k
h2 : ble (k * k) n = false
⊢ 2 ≤ n ∧ ∀ (m : ℕ), 2 ≤ m → m ≤ sqrt n → ¬m ∣ n

tactic: exact lt_irrefl m <| calc
  m ≤ sqrt n   := hmn
  _ < k        := sqrt_lt.mpr (ble_eq_false.mp h2)
  _ ≤ n.minFac := h1.2.2
  _ ≤ m        := Nat.minFac_le_of_dvd hm h2mn
state_before: n k : ℕ
h1 : MinFacHelper n k
h2 : ble (k * k) n = false
m : ℕ
hm : 2 ≤ m
hmn : m ≤ sqrt n
h2mn : m ∣ n
⊢ False
Theorem: mulSalemSpencer_pair
File: Mathlib/Combinatorics/Additive/SalemSpencer.lean

tactic: rw [mulSalemSpencer_insert]
state_before: F : Type ?u.75150
α : Type u_1
β : Type ?u.75156
𝕜 : Type ?u.75159
E : Type ?u.75162
inst✝ : CancelCommMonoid α
s : Set α
a✝ a b : α
⊢ MulSalemSpencer {a, b}

tactic: refine' ⟨mulSalemSpencer_singleton _, _, _⟩
state_before: F : Type ?u.75150
α : Type u_1
β : Type ?u.75156
𝕜 : Type ?u.75159
E : Type ?u.75162
inst✝ : CancelCommMonoid α
s : Set α
a✝ a b : α
⊢ MulSalemSpencer {b} ∧
    (∀ ⦃b_1 c : α⦄, b_1 ∈ {b} → c ∈ {b} → a * b_1 = c * c → a = b_1) ∧
      ∀ ⦃b_1 c : α⦄, b_1 ∈ {b} → c ∈ {b} → b_1 * c = a * a → b_1 = c

tactic: rintro c d (rfl : c = b) (rfl : d = c)
state_before: case refine'_1
F : Type ?u.75150
α : Type u_1
β : Type ?u.75156
𝕜 : Type ?u.75159
E : Type ?u.75162
inst✝ : CancelCommMonoid α
s : Set α
a✝ a b : α
⊢ ∀ ⦃b_1 c : α⦄, b_1 ∈ {b} → c ∈ {b} → a * b_1 = c * c → a = b_1

tactic: exact mul_right_cancel
state_before: case refine'_1
F : Type ?u.75150
α : Type u_1
β : Type ?u.75156
𝕜 : Type ?u.75159
E : Type ?u.75162
inst✝ : CancelCommMonoid α
s : Set α
a✝ a d : α
⊢ a * d = d * d → a = d

tactic: rintro c d (rfl : c = b) (rfl : d = c) _
state_before: case refine'_2
F : Type ?u.75150
α : Type u_1
β : Type ?u.75156
𝕜 : Type ?u.75159
E : Type ?u.75162
inst✝ : CancelCommMonoid α
s : Set α
a✝ a b : α
⊢ ∀ ⦃b_1 c : α⦄, b_1 ∈ {b} → c ∈ {b} → b_1 * c = a * a → b_1 = c

tactic: rfl
state_before: case refine'_2
F : Type ?u.75150
α : Type u_1
β : Type ?u.75156
𝕜 : Type ?u.75159
E : Type ?u.75162
inst✝ : CancelCommMonoid α
s : Set α
a✝¹ a d : α
a✝ : d * d = a * a
⊢ d = d
Theorem: MeasureTheory.nonempty_inter_of_measure_lt_add'
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [add_comm] at h
state_before: α : Type u_1
β : Type ?u.45468
γ : Type ?u.45471
δ : Type ?u.45474
ι : Type ?u.45477
R : Type ?u.45480
R' : Type ?u.45483
m✝ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
m : MeasurableSpace α
μ : Measure α
s t u : Set α
hs : MeasurableSet s
h's : s ⊆ u
h't : t ⊆ u
h : ↑↑μ u < ↑↑μ s + ↑↑μ t
⊢ Set.Nonempty (s ∩ t)

tactic: rw [inter_comm]
state_before: α : Type u_1
β : Type ?u.45468
γ : Type ?u.45471
δ : Type ?u.45474
ι : Type ?u.45477
R : Type ?u.45480
R' : Type ?u.45483
m✝ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
m : MeasurableSpace α
μ : Measure α
s t u : Set α
hs : MeasurableSet s
h's : s ⊆ u
h't : t ⊆ u
h : ↑↑μ u < ↑↑μ t + ↑↑μ s
⊢ Set.Nonempty (s ∩ t)

tactic: exact nonempty_inter_of_measure_lt_add μ hs h't h's h
state_before: α : Type u_1
β : Type ?u.45468
γ : Type ?u.45471
δ : Type ?u.45474
ι : Type ?u.45477
R : Type ?u.45480
R' : Type ?u.45483
m✝ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
m : MeasurableSpace α
μ : Measure α
s t u : Set α
hs : MeasurableSet s
h's : s ⊆ u
h't : t ⊆ u
h : ↑↑μ u < ↑↑μ t + ↑↑μ s
⊢ Set.Nonempty (t ∩ s)
Theorem: Set.pairwise_insert_of_not_mem
File: Mathlib/Data/Set/Pairwise/Basic.lean

tactic: simp [(ne_of_mem_of_not_mem hb ha).symm]
state_before: α : Type u_1
β : Type ?u.10660
γ : Type ?u.10663
ι : Type ?u.10666
ι' : Type ?u.10669
r p q : α → α → Prop
f g : ι → α
s t u : Set α
a b✝ : α
ha : ¬a ∈ s
b : α
hb : b ∈ s
⊢ a ≠ b → r a b ∧ r b a ↔ r a b ∧ r b a
Theorem: MeasureTheory.Measure.restrict_union_le
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: intro t ht
state_before: α : Type u_1
β : Type ?u.299320
γ : Type ?u.299323
δ : Type ?u.299326
ι : Type ?u.299329
R : Type ?u.299332
R' : Type ?u.299335
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s'✝ t s s' : Set α
⊢ restrict μ (s ∪ s') ≤ restrict μ s + restrict μ s'

tactic: suffices μ (t ∩ s ∪ t ∩ s') ≤ μ (t ∩ s) + μ (t ∩ s') by simpa [ht, inter_union_distrib_left]
state_before: α : Type u_1
β : Type ?u.299320
γ : Type ?u.299323
δ : Type ?u.299326
ι : Type ?u.299329
R : Type ?u.299332
R' : Type ?u.299335
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s'✝ t✝ s s' t : Set α
ht : MeasurableSet t
⊢ ↑↑(restrict μ (s ∪ s')) t ≤ ↑↑(restrict μ s + restrict μ s') t

tactic: apply measure_union_le
state_before: α : Type u_1
β : Type ?u.299320
γ : Type ?u.299323
δ : Type ?u.299326
ι : Type ?u.299329
R : Type ?u.299332
R' : Type ?u.299335
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s'✝ t✝ s s' t : Set α
ht : MeasurableSet t
⊢ ↑↑μ (t ∩ s ∪ t ∩ s') ≤ ↑↑μ (t ∩ s) + ↑↑μ (t ∩ s')

tactic: simpa [ht, inter_union_distrib_left]
state_before: α : Type u_1
β : Type ?u.299320
γ : Type ?u.299323
δ : Type ?u.299326
ι : Type ?u.299329
R : Type ?u.299332
R' : Type ?u.299335
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s'✝ t✝ s s' t : Set α
ht : MeasurableSet t
this : ↑↑μ (t ∩ s ∪ t ∩ s') ≤ ↑↑μ (t ∩ s) + ↑↑μ (t ∩ s')
⊢ ↑↑(restrict μ (s ∪ s')) t ≤ ↑↑(restrict μ s + restrict μ s') t
Theorem: CategoryTheory.Splitting.section_π
File: Mathlib/Algebra/Homology/ShortExact/Preadditive.lean

tactic: simp [Splitting.section]
state_before: 𝒜 : Type u_2
inst✝² : Category 𝒜
A B C A' B' C' : 𝒜
f : A ⟶ B
g : B ⟶ C
f' : A' ⟶ B'
g' : B' ⟶ C'
inst✝¹ : HasZeroMorphisms 𝒜
inst✝ : HasBinaryBiproducts 𝒜
h : Splitting f g
⊢ section h ≫ g = 𝟙 C
Theorem: Int.bitwise_diff
File: Mathlib/Data/Int/Bitwise.lean

tactic: funext m n
state_before: ⊢ (bitwise fun a b => a && !b) = ldiff'

tactic: cases' m with m m <;> cases' n with n n <;> try {rfl}
  <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true,
    cond_false, cond_true, lor, Nat.ldiff', Bool.and_true, negSucc.injEq,
    Bool.and_false, Nat.land', Bool.not_true, ldiff', Nat.lor']
state_before: case h.h
m n : ℤ
⊢ bitwise (fun a b => a && !b) m n = ldiff' m n

tactic: . congr
  funext x y
  cases x <;> cases y <;> rfl
state_before: case h.h.ofNat.negSucc
m n : ℕ
⊢ ↑(Nat.bitwise' (fun x y => x && !!y) m n) = ↑(Nat.bitwise' and m n)

case h.h.negSucc.ofNat
m n : ℕ
⊢ Nat.bitwise' (fun x y => !(!x && !y)) m n = Nat.bitwise' or m n

case h.h.negSucc.negSucc
m n : ℕ
⊢ ↑(Nat.bitwise' (fun x y => !x && !!y) m n) = ↑(Nat.bitwise' (fun a b => a && !b) n m)

tactic: . congr
  funext x y
  cases x <;> cases y <;> rfl
state_before: case h.h.negSucc.ofNat
m n : ℕ
⊢ Nat.bitwise' (fun x y => !(!x && !y)) m n = Nat.bitwise' or m n

case h.h.negSucc.negSucc
m n : ℕ
⊢ ↑(Nat.bitwise' (fun x y => !x && !!y) m n) = ↑(Nat.bitwise' (fun a b => a && !b) n m)

tactic: . rw [Nat.bitwise'_swap, Function.swap]
  congr
  funext x y
  cases x <;> cases y <;> rfl
  rfl
state_before: case h.h.negSucc.negSucc
m n : ℕ
⊢ ↑(Nat.bitwise' (fun x y => !x && !!y) m n) = ↑(Nat.bitwise' (fun a b => a && !b) n m)

tactic: congr
state_before: case h.h.ofNat.negSucc
m n : ℕ
⊢ ↑(Nat.bitwise' (fun x y => x && !!y) m n) = ↑(Nat.bitwise' and m n)

tactic: funext x y
state_before: case h.h.ofNat.negSucc.e_a.e_f
m n : ℕ
⊢ (fun x y => x && !!y) = and

tactic: cases x <;> cases y <;> rfl
state_before: case h.h.ofNat.negSucc.e_a.e_f.h.h
m n : ℕ
x y : Bool
⊢ (x && !!y) = (x && y)

tactic: congr
state_before: case h.h.negSucc.ofNat
m n : ℕ
⊢ Nat.bitwise' (fun x y => !(!x && !y)) m n = Nat.bitwise' or m n

tactic: funext x y
state_before: case h.h.negSucc.ofNat.e_f
m n : ℕ
⊢ (fun x y => !(!x && !y)) = or

tactic: cases x <;> cases y <;> rfl
state_before: case h.h.negSucc.ofNat.e_f.h.h
m n : ℕ
x y : Bool
⊢ (!(!x && !y)) = (x || y)

tactic: rw [Nat.bitwise'_swap, Function.swap]
state_before: case h.h.negSucc.negSucc
m n : ℕ
⊢ ↑(Nat.bitwise' (fun x y => !x && !!y) m n) = ↑(Nat.bitwise' (fun a b => a && !b) n m)

tactic: congr
state_before: case h.h.negSucc.negSucc
m n : ℕ
⊢ ↑(Nat.bitwise' (fun y x => !x && !!y) n m) = ↑(Nat.bitwise' (fun a b => a && !b) n m)

case h.h.negSucc.negSucc
m n : ℕ
⊢ (!false && !!false) = false

tactic: funext x y
state_before: case h.h.negSucc.negSucc.e_a.e_f
m n : ℕ
⊢ (fun y x => !x && !!y) = fun a b => a && !b

case h.h.negSucc.negSucc
m n : ℕ
⊢ (!false && !!false) = false

tactic: cases x <;> cases y <;> rfl
state_before: case h.h.negSucc.negSucc.e_a.e_f.h.h
m n : ℕ
x y : Bool
⊢ (!y && !!x) = (x && !y)

case h.h.negSucc.negSucc
m n : ℕ
⊢ (!false && !!false) = false

tactic: rfl
state_before: case h.h.negSucc.negSucc
m n : ℕ
⊢ (!false && !!false) = false
Theorem: Stream'.mem_of_mem_even
File: Mathlib/Data/Stream/Init.lean

tactic: rw [h, nth_even]
state_before: α : Type u
β : Type v
δ : Type w
a : α
s : Stream' α
x✝ : a ∈ even s
n : ℕ
h : (fun b => a = b) (nth (even s) n)
⊢ (fun b => a = b) (nth s (2 * n))
Theorem: MonoidHom.transfer_sylow_eq_pow_aux
File: Mathlib/GroupTheory/Transfer.lean

tactic: haveI : (P : Subgroup G).IsCommutative :=
  ⟨⟨fun a b => Subtype.ext (hP (le_normalizer b.2) a a.2)⟩⟩
state_before: G : Type u_1
inst✝³ : Group G
H : Subgroup G
A : Type ?u.1048622
inst✝² : CommGroup A
ϕ : { x // x ∈ H } →* A
T : ↑(leftTransversals ↑H)
p : ℕ
P : Sylow p G
hP : normalizer ↑P ≤ centralizer ↑P
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
g : G
hg : g ∈ P
k : ℕ
g₀ : G
h : g₀⁻¹ * g ^ k * g₀ ∈ P
⊢ g₀⁻¹ * g ^ k * g₀ = g ^ k

tactic: replace hg := (P : Subgroup G).pow_mem hg k
state_before: G : Type u_1
inst✝³ : Group G
H : Subgroup G
A : Type ?u.1048622
inst✝² : CommGroup A
ϕ : { x // x ∈ H } →* A
T : ↑(leftTransversals ↑H)
p : ℕ
P : Sylow p G
hP : normalizer ↑P ≤ centralizer ↑P
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
g : G
hg : g ∈ P
k : ℕ
g₀ : G
h : g₀⁻¹ * g ^ k * g₀ ∈ P
this : Subgroup.IsCommutative ↑P
⊢ g₀⁻¹ * g ^ k * g₀ = g ^ k

tactic: obtain ⟨n, hn, h⟩ := P.conj_eq_normalizer_conj_of_mem (g ^ k) g₀ hg h
state_before: G : Type u_1
inst✝³ : Group G
H : Subgroup G
A : Type ?u.1048622
inst✝² : CommGroup A
ϕ : { x // x ∈ H } →* A
T : ↑(leftTransversals ↑H)
p : ℕ
P : Sylow p G
hP : normalizer ↑P ≤ centralizer ↑P
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
g : G
k : ℕ
g₀ : G
h : g₀⁻¹ * g ^ k * g₀ ∈ P
this : Subgroup.IsCommutative ↑P
hg : g ^ k ∈ ↑P
⊢ g₀⁻¹ * g ^ k * g₀ = g ^ k

tactic: exact h.trans (Commute.inv_mul_cancel (hP hn (g ^ k) hg).symm)
state_before: case intro.intro
G : Type u_1
inst✝³ : Group G
H : Subgroup G
A : Type ?u.1048622
inst✝² : CommGroup A
ϕ : { x // x ∈ H } →* A
T : ↑(leftTransversals ↑H)
p : ℕ
P : Sylow p G
hP : normalizer ↑P ≤ centralizer ↑P
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
g : G
k : ℕ
g₀ : G
h✝ : g₀⁻¹ * g ^ k * g₀ ∈ P
this : Subgroup.IsCommutative ↑P
hg : g ^ k ∈ ↑P
n : G
hn : n ∈ normalizer ↑P
h : g₀⁻¹ * g ^ k * g₀ = n⁻¹ * g ^ k * n
⊢ g₀⁻¹ * g ^ k * g₀ = g ^ k
Theorem: isOpen_iff_ultrafilter
File: Mathlib/Topology/Basic.lean

tactic: simp_rw [isOpen_iff_mem_nhds, ← mem_iff_ultrafilter]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
⊢ IsOpen s ↔ ∀ (x : α), x ∈ s → ∀ (l : Ultrafilter α), ↑l ≤ 𝓝 x → s ∈ l
Theorem: NormedRing.inverse_add_norm
File: Mathlib/Analysis/NormedSpace/Units.lean

tactic: refine EventuallyEq.trans_isBigO (inverse_add x) (one_mul (1 : ℝ) ▸ ?_)
state_before: R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : Rˣ
⊢ (fun t => inverse (↑x + t)) =O[𝓝 0] fun _t => 1

tactic: simp only [← sub_neg_eq_add, ← neg_mul]
state_before: R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : Rˣ
⊢ (fun x_1 => inverse (1 + ↑x⁻¹ * x_1) * ↑x⁻¹) =O[𝓝 0] fun _t => 1 * 1

tactic: exact (inverse_one_sub_norm.comp_tendsto hzero).mul (isBigO_const_const _ one_ne_zero _)
state_before: R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : Rˣ
hzero : Tendsto (fun x_1 => -↑x⁻¹ * x_1) (𝓝 0) (𝓝 0)
⊢ (fun x_1 => inverse (1 - -↑x⁻¹ * x_1) * ↑x⁻¹) =O[𝓝 0] fun _t => 1 * 1
Theorem: Part.get_eq_iff_eq_some
File: Mathlib/Data/Part.lean

tactic: simp [h.symm]
state_before: α : Type u_1
β : Type ?u.6173
γ : Type ?u.6176
a : Part α
ha : a.Dom
b : α
h : get a ha = b
⊢ a = some b

tactic: simp [h]
state_before: α : Type u_1
β : Type ?u.6173
γ : Type ?u.6176
a : Part α
ha : a.Dom
b : α
h : a = some b
⊢ get a ha = b
Theorem: equicontinuousAt_iff_continuousAt
File: Mathlib/Topology/UniformSpace/Equicontinuity.lean

tactic: rw [ContinuousAt, (UniformFun.hasBasis_nhds ι α _).tendsto_right_iff]
state_before: ι : Type u_1
κ : Type ?u.58187
X : Type u_2
Y : Type ?u.58193
Z : Type ?u.58196
α : Type u_3
β : Type ?u.58202
γ : Type ?u.58205
𝓕 : Type ?u.58208
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
F : ι → X → α
x₀ : X
⊢ EquicontinuousAt F x₀ ↔ ContinuousAt (↑UniformFun.ofFun ∘ Function.swap F) x₀

tactic: rfl
state_before: ι : Type u_1
κ : Type ?u.58187
X : Type u_2
Y : Type ?u.58193
Z : Type ?u.58196
α : Type u_3
β : Type ?u.58202
γ : Type ?u.58205
𝓕 : Type ?u.58208
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
F : ι → X → α
x₀ : X
⊢ EquicontinuousAt F x₀ ↔
    ∀ (i : Set (α × α)),
      i ∈ 𝓤 α →
        ∀ᶠ (x : X) in 𝓝 x₀,
          (↑UniformFun.ofFun ∘ Function.swap F) x ∈
            {g | ((↑UniformFun.ofFun ∘ Function.swap F) x₀, g) ∈ UniformFun.gen ι α i}
Theorem: Int.fract_add_le
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [fract, fract, fract, sub_add_sub_comm, sub_le_sub_iff_left, ← Int.cast_add, Int.cast_le]
state_before: F : Type ?u.150574
α : Type u_1
β : Type ?u.150580
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ fract (a + b) ≤ fract a + fract b

tactic: exact le_floor_add _ _
state_before: F : Type ?u.150574
α : Type u_1
β : Type ?u.150580
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ ⌊a⌋ + ⌊b⌋ ≤ ⌊a + b⌋
Theorem: CategoryTheory.Functor.epi_map_iff_epi
File: Mathlib/CategoryTheory/Functor/EpiMono.lean

tactic: constructor
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
F : C ⥤ D
X Y : C
f : X ⟶ Y
hF₁ : PreservesEpimorphisms F
hF₂ : ReflectsEpimorphisms F
⊢ Epi (F.map f) ↔ Epi f

tactic: exact F.epi_of_epi_map
state_before: case mp
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
F : C ⥤ D
X Y : C
f : X ⟶ Y
hF₁ : PreservesEpimorphisms F
hF₂ : ReflectsEpimorphisms F
⊢ Epi (F.map f) → Epi f

tactic: intro h
state_before: case mpr
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
F : C ⥤ D
X Y : C
f : X ⟶ Y
hF₁ : PreservesEpimorphisms F
hF₂ : ReflectsEpimorphisms F
⊢ Epi f → Epi (F.map f)

tactic: exact F.map_epi f
state_before: case mpr
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
F : C ⥤ D
X Y : C
f : X ⟶ Y
hF₁ : PreservesEpimorphisms F
hF₂ : ReflectsEpimorphisms F
h : Epi f
⊢ Epi (F.map f)
Theorem: Real.smul_map_volume_mul_left
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

tactic: refine' (Real.measure_ext_Ioo_rat fun p q => _).symm
state_before: ι : Type ?u.2199955
inst✝ : Fintype ι
a : ℝ
h : a ≠ 0
⊢ ofReal (abs a) • Measure.map (fun x => a * x) volume = volume

tactic: cases' lt_or_gt_of_ne h with h h
state_before: ι : Type ?u.2199955
inst✝ : Fintype ι
a : ℝ
h : a ≠ 0
p q : ℚ
⊢ ↑↑volume (Ioo ↑p ↑q) = ↑↑(ofReal (abs a) • Measure.map (fun x => a * x) volume) (Ioo ↑p ↑q)

tactic: simp only [Real.volume_Ioo, Measure.smul_apply, ← ENNReal.ofReal_mul (le_of_lt <| neg_pos.2 h),
  Measure.map_apply (measurable_const_mul a) measurableSet_Ioo, neg_sub_neg, neg_mul,
  preimage_const_mul_Ioo_of_neg _ _ h, abs_of_neg h, mul_sub, smul_eq_mul,
  mul_div_cancel' _ (ne_of_lt h)]
state_before: case inl
ι : Type ?u.2199955
inst✝ : Fintype ι
a : ℝ
h✝ : a ≠ 0
p q : ℚ
h : a < 0
⊢ ↑↑volume (Ioo ↑p ↑q) = ↑↑(ofReal (abs a) • Measure.map (fun x => a * x) volume) (Ioo ↑p ↑q)

tactic: simp only [Real.volume_Ioo, Measure.smul_apply, ← ENNReal.ofReal_mul (le_of_lt h),
  Measure.map_apply (measurable_const_mul a) measurableSet_Ioo, preimage_const_mul_Ioo _ _ h,
  abs_of_pos h, mul_sub, mul_div_cancel' _ (ne_of_gt h), smul_eq_mul]
state_before: case inr
ι : Type ?u.2199955
inst✝ : Fintype ι
a : ℝ
h✝ : a ≠ 0
p q : ℚ
h : a > 0
⊢ ↑↑volume (Ioo ↑p ↑q) = ↑↑(ofReal (abs a) • Measure.map (fun x => a * x) volume) (Ioo ↑p ↑q)
Theorem: IsCoprime.of_add_mul_left_left
File: Mathlib/RingTheory/Coprime/Basic.lean

tactic: simpa only [add_mul, mul_add, add_assoc, add_comm, add_left_comm, mul_assoc, mul_comm,
  mul_left_comm] using H
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
h : IsCoprime (x + y * z) y
a b : R
H : a * (x + y * z) + b * y = 1
⊢ a * x + (a * z + b) * y = 1