tasksource/leandojo huggingface dataset:
Theorem: Ordinal.enumOrd_range
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: apply Ordinal.induction o
state_before: S : Set Ordinal
f : Ordinal → Ordinal
hf : StrictMono f
o : Ordinal
⊢ enumOrd (range f) o = f o

tactic: intro a H
state_before: S : Set Ordinal
f : Ordinal → Ordinal
hf : StrictMono f
o : Ordinal
⊢ ∀ (j : Ordinal), (∀ (k : Ordinal), k < j → enumOrd (range f) k = f k) → enumOrd (range f) j = f j

tactic: rw [enumOrd_def a]
state_before: S : Set Ordinal
f : Ordinal → Ordinal
hf : StrictMono f
o a : Ordinal
H : ∀ (k : Ordinal), k < a → enumOrd (range f) k = f k
⊢ enumOrd (range f) a = f a

tactic: have Hfa : f a ∈ range f ∩ { b | ∀ c, c < a → enumOrd (range f) c < b } :=
  ⟨mem_range_self a, fun b hb => by
    rw [H b hb]
    exact hf hb⟩
state_before: S : Set Ordinal
f : Ordinal → Ordinal
hf : StrictMono f
o a : Ordinal
H : ∀ (k : Ordinal), k < a → enumOrd (range f) k = f k
⊢ sInf (range f ∩ {b | ∀ (c : Ordinal), c < a → enumOrd (range f) c < b}) = f a

tactic: refine' (csInf_le' Hfa).antisymm ((le_csInf_iff'' ⟨_, Hfa⟩).2 _)
state_before: S : Set Ordinal
f : Ordinal → Ordinal
hf : StrictMono f
o a : Ordinal
H : ∀ (k : Ordinal), k < a → enumOrd (range f) k = f k
Hfa : f a ∈ range f ∩ {b | ∀ (c : Ordinal), c < a → enumOrd (range f) c < b}
⊢ sInf (range f ∩ {b | ∀ (c : Ordinal), c < a → enumOrd (range f) c < b}) = f a

tactic: rintro _ ⟨⟨c, rfl⟩, hc : ∀ b < a, enumOrd (range f) b < f c⟩
state_before: S : Set Ordinal
f : Ordinal → Ordinal
hf : StrictMono f
o a : Ordinal
H : ∀ (k : Ordinal), k < a → enumOrd (range f) k = f k
Hfa : f a ∈ range f ∩ {b | ∀ (c : Ordinal), c < a → enumOrd (range f) c < b}
⊢ ∀ (b : Ordinal), b ∈ range f ∩ {b | ∀ (c : Ordinal), c < a → enumOrd (range f) c < b} → f a ≤ b

tactic: rw [hf.le_iff_le]
state_before: case intro.intro
S : Set Ordinal
f : Ordinal → Ordinal
hf : StrictMono f
o a : Ordinal
H : ∀ (k : Ordinal), k < a → enumOrd (range f) k = f k
Hfa : f a ∈ range f ∩ {b | ∀ (c : Ordinal), c < a → enumOrd (range f) c < b}
c : Ordinal
hc : ∀ (b : Ordinal), b < a → enumOrd (range f) b < f c
⊢ f a ≤ f c

tactic: contrapose! hc
state_before: case intro.intro
S : Set Ordinal
f : Ordinal → Ordinal
hf : StrictMono f
o a : Ordinal
H : ∀ (k : Ordinal), k < a → enumOrd (range f) k = f k
Hfa : f a ∈ range f ∩ {b | ∀ (c : Ordinal), c < a → enumOrd (range f) c < b}
c : Ordinal
hc : ∀ (b : Ordinal), b < a → enumOrd (range f) b < f c
⊢ a ≤ c

tactic: exact ⟨c, hc, (H c hc).ge⟩
state_before: case intro.intro
S : Set Ordinal
f : Ordinal → Ordinal
hf : StrictMono f
o a : Ordinal
H : ∀ (k : Ordinal), k < a → enumOrd (range f) k = f k
Hfa : f a ∈ range f ∩ {b | ∀ (c : Ordinal), c < a → enumOrd (range f) c < b}
c : Ordinal
hc : c < a
⊢ ∃ b, b < a ∧ f c ≤ enumOrd (range f) b

tactic: rw [H b hb]
state_before: S : Set Ordinal
f : Ordinal → Ordinal
hf : StrictMono f
o a : Ordinal
H : ∀ (k : Ordinal), k < a → enumOrd (range f) k = f k
b : Ordinal
hb : b < a
⊢ enumOrd (range f) b < f a

tactic: exact hf hb
state_before: S : Set Ordinal
f : Ordinal → Ordinal
hf : StrictMono f
o a : Ordinal
H : ∀ (k : Ordinal), k < a → enumOrd (range f) k = f k
b : Ordinal
hb : b < a
⊢ f b < f a
Theorem: Int.add_emod_self
File: Std/Data/Int/DivMod.lean

tactic: have := add_mul_emod_self_left a b 1
state_before: a b : Int
⊢ (a + b) % b = a % b

tactic: rwa [Int.mul_one] at this
state_before: a b : Int
this : (a + b * 1) % b = a % b
⊢ (a + b) % b = a % b
Theorem: FiniteDimensional.not_linearIndependent_of_infinite
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: intro h_lin_indep
state_before: K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type w
inf : Infinite ι
inst✝ : FiniteDimensional K V
v : ι → V
⊢ ¬LinearIndependent K v

tactic: have : ¬ℵ₀ ≤ (#ι) := not_le.mpr (lt_aleph0_of_linearIndependent h_lin_indep)
state_before: K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type w
inf : Infinite ι
inst✝ : FiniteDimensional K V
v : ι → V
h_lin_indep : LinearIndependent K v
⊢ False

tactic: have : ℵ₀ ≤ (#ι) := infinite_iff.mp inf
state_before: K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type w
inf : Infinite ι
inst✝ : FiniteDimensional K V
v : ι → V
h_lin_indep : LinearIndependent K v
this : ¬ℵ₀ ≤ (#ι)
⊢ False

tactic: contradiction
state_before: K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type w
inf : Infinite ι
inst✝ : FiniteDimensional K V
v : ι → V
h_lin_indep : LinearIndependent K v
this✝ : ¬ℵ₀ ≤ (#ι)
this : ℵ₀ ≤ (#ι)
⊢ False
Theorem: Filter.HasBasis.restrict
File: Mathlib/Order/Filter/Bases.lean

tactic: refine' ⟨fun t => ⟨fun ht => _, fun ⟨i, hpi, hti⟩ => h.mem_iff.2 ⟨i, hpi.1, hti⟩⟩⟩
state_before: α : Type u_1
β : Type ?u.23444
γ : Type ?u.23447
ι : Sort u_2
ι' : Sort ?u.23453
l l' : Filter α
p : ι → Prop
s : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
h : HasBasis l p s
q : ι → Prop
hq : ∀ (i : ι), p i → ∃ j, p j ∧ q j ∧ s j ⊆ s i
⊢ HasBasis l (fun i => p i ∧ q i) s

tactic: rcases h.mem_iff.1 ht with ⟨i, hpi, hti⟩
state_before: α : Type u_1
β : Type ?u.23444
γ : Type ?u.23447
ι : Sort u_2
ι' : Sort ?u.23453
l l' : Filter α
p : ι → Prop
s : ι → Set α
t✝ : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
h : HasBasis l p s
q : ι → Prop
hq : ∀ (i : ι), p i → ∃ j, p j ∧ q j ∧ s j ⊆ s i
t : Set α
ht : t ∈ l
⊢ ∃ i, (p i ∧ q i) ∧ s i ⊆ t

tactic: rcases hq i hpi with ⟨j, hpj, hqj, hji⟩
state_before: case intro.intro
α : Type u_1
β : Type ?u.23444
γ : Type ?u.23447
ι : Sort u_2
ι' : Sort ?u.23453
l l' : Filter α
p : ι → Prop
s : ι → Set α
t✝ : Set α
i✝ : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
h : HasBasis l p s
q : ι → Prop
hq : ∀ (i : ι), p i → ∃ j, p j ∧ q j ∧ s j ⊆ s i
t : Set α
ht : t ∈ l
i : ι
hpi : p i
hti : s i ⊆ t
⊢ ∃ i, (p i ∧ q i) ∧ s i ⊆ t

tactic: exact ⟨j, ⟨hpj, hqj⟩, hji.trans hti⟩
state_before: case intro.intro.intro.intro.intro
α : Type u_1
β : Type ?u.23444
γ : Type ?u.23447
ι : Sort u_2
ι' : Sort ?u.23453
l l' : Filter α
p : ι → Prop
s : ι → Set α
t✝ : Set α
i✝ : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
h : HasBasis l p s
q : ι → Prop
hq : ∀ (i : ι), p i → ∃ j, p j ∧ q j ∧ s j ⊆ s i
t : Set α
ht : t ∈ l
i : ι
hpi : p i
hti : s i ⊆ t
j : ι
hpj : p j
hqj : q j
hji : s j ⊆ s i
⊢ ∃ i, (p i ∧ q i) ∧ s i ⊆ t
Theorem: CategoryTheory.isSeparator_op_iff
File: Mathlib/CategoryTheory/Generator.lean

tactic: rw [IsSeparator, IsCoseparator, ← isSeparating_op_iff, Set.singleton_op]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
G : C
⊢ IsSeparator G.op ↔ IsCoseparator G
Theorem: smul_closedBall
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

tactic: rcases eq_or_ne c 0 with (rfl | hc)
state_before: 𝕜 : Type u_2
E : Type u_1
inst✝² : NormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
c : 𝕜
x : E
r : ℝ
hr : 0 ≤ r
⊢ c • closedBall x r = closedBall (c • x) (‖c‖ * r)

tactic: simp [hr, zero_smul_set, Set.singleton_zero, ← nonempty_closedBall]
state_before: case inl
𝕜 : Type u_2
E : Type u_1
inst✝² : NormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : E
r : ℝ
hr : 0 ≤ r
⊢ 0 • closedBall x r = closedBall (0 • x) (‖0‖ * r)

tactic: exact smul_closedBall' hc x r
state_before: case inr
𝕜 : Type u_2
E : Type u_1
inst✝² : NormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
c : 𝕜
x : E
r : ℝ
hr : 0 ≤ r
hc : c ≠ 0
⊢ c • closedBall x r = closedBall (c • x) (‖c‖ * r)
Theorem: Nat.two_dvd_centralBinom_of_one_le
File: Mathlib/Data/Nat/Choose/Central.lean

tactic: rw [← Nat.succ_pred_eq_of_pos h]
state_before: n : ℕ
h : 0 < n
⊢ 2 ∣ centralBinom n

tactic: exact two_dvd_centralBinom_succ n.pred
state_before: n : ℕ
h : 0 < n
⊢ 2 ∣ centralBinom (succ (pred n))
Theorem: Asymptotics.isBigOWith_inv
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp only [IsBigOWith_def, ← div_eq_inv_mul, le_div_iff' hc]
state_before: α : Type u_1
β : Type ?u.45377
E : Type u_2
F : Type u_3
G : Type ?u.45386
E' : Type ?u.45389
F' : Type ?u.45392
G' : Type ?u.45395
E'' : Type ?u.45398
F'' : Type ?u.45401
G'' : Type ?u.45404
R : Type ?u.45407
R' : Type ?u.45410
𝕜 : Type ?u.45413
𝕜' : Type ?u.45416
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''
k'' : α → G''
l l' : Filter α
hc : 0 < c
⊢ IsBigOWith c⁻¹ l f g ↔ ∀ᶠ (x : α) in l, c * ‖f x‖ ≤ ‖g x‖
Theorem: SimpleGraph.Dart.ext_iff
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: cases d₁
state_before: ι : Sort ?u.94190
𝕜 : Type ?u.94193
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
d₁ d₂ : Dart G
⊢ d₁ = d₂ ↔ d₁.toProd = d₂.toProd

tactic: cases d₂
state_before: case mk
ι : Sort ?u.94190
𝕜 : Type ?u.94193
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
d₂ : Dart G
toProd✝ : V × V
is_adj✝ : Adj G toProd✝.fst toProd✝.snd
⊢ { toProd := toProd✝, is_adj := is_adj✝ } = d₂ ↔ { toProd := toProd✝, is_adj := is_adj✝ }.toProd = d₂.toProd

tactic: simp
state_before: case mk.mk
ι : Sort ?u.94190
𝕜 : Type ?u.94193
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
toProd✝¹ : V × V
is_adj✝¹ : Adj G toProd✝¹.fst toProd✝¹.snd
toProd✝ : V × V
is_adj✝ : Adj G toProd✝.fst toProd✝.snd
⊢ { toProd := toProd✝¹, is_adj := is_adj✝¹ } = { toProd := toProd✝, is_adj := is_adj✝ } ↔
    { toProd := toProd✝¹, is_adj := is_adj✝¹ }.toProd = { toProd := toProd✝, is_adj := is_adj✝ }.toProd
Theorem: Finset.card_mul_mul_le_card_div_mul_card_mul
File: Mathlib/Combinatorics/Additive/PluenneckeRuzsa.lean

tactic: rw [← div_inv_eq_mul, ← div_inv_eq_mul B]
state_before: α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
⊢ card (A * C) * card B ≤ card (A / B) * card (B * C)

tactic: exact card_div_mul_le_card_div_mul_card_div _ _ _
state_before: α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
⊢ card (A / C⁻¹) * card B ≤ card (A / B) * card (B / C⁻¹)
Theorem: Matrix.cramer_eq_adjugate_mulVec
File: Mathlib/LinearAlgebra/Matrix/Adjugate.lean

tactic: nth_rw 2 [← A.transpose_transpose]
state_before: m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix n n α
b : n → α
⊢ ↑(cramer A) b = mulVec (adjugate A) b

tactic: rw [← adjugate_transpose, adjugate_def]
state_before: m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix n n α
b : n → α
⊢ ↑(cramer A) b = mulVec (adjugate Aᵀᵀ) b

tactic: have : b = ∑ i, b i • Pi.single i 1 := by
  refine' (pi_eq_sum_univ b).trans _
  congr with j
  simp [Pi.single_apply, eq_comm, Pi.smul_apply (b j)]
state_before: m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix n n α
b : n → α
⊢ ↑(cramer A) b = mulVec (↑of fun i => ↑(cramer Aᵀᵀ) (Pi.single i 1))ᵀ b

tactic: conv_lhs =>
  rw [this]
state_before: m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix n n α
b : n → α
this : b = ∑ i : n, b i • Pi.single i 1
⊢ ↑(cramer A) b = mulVec (↑of fun i => ↑(cramer Aᵀᵀ) (Pi.single i 1))ᵀ b

tactic: ext k
state_before: m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix n n α
b : n → α
this : b = ∑ i : n, b i • Pi.single i 1
⊢ ↑(cramer A) (∑ i : n, b i • Pi.single i 1) = mulVec (↑of fun i => ↑(cramer Aᵀᵀ) (Pi.single i 1))ᵀ b

tactic: simp [mulVec, dotProduct, mul_comm]
state_before: case h
m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix n n α
b : n → α
this : b = ∑ i : n, b i • Pi.single i 1
k : n
⊢ ↑(cramer A) (∑ i : n, b i • Pi.single i 1) k = mulVec (↑of fun i => ↑(cramer Aᵀᵀ) (Pi.single i 1))ᵀ b k

tactic: refine' (pi_eq_sum_univ b).trans _
state_before: m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix n n α
b : n → α
⊢ b = ∑ i : n, b i • Pi.single i 1

tactic: congr with j
state_before: m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix n n α
b : n → α
⊢ (∑ i : n, b i • fun j => if i = j then 1 else 0) = ∑ i : n, b i • Pi.single i 1

tactic: simp [Pi.single_apply, eq_comm, Pi.smul_apply (b j)]
state_before: case e_f.h.h
m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix n n α
b : n → α
j x✝ : n
⊢ (b j • fun j_1 => if j = j_1 then 1 else 0) x✝ = (b j • Pi.single j 1) x✝
Theorem: tendsto_norm_cocompact_atTop'
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simpa only [dist_one_right] using tendsto_dist_right_cocompact_atTop (1 : E)
state_before: 𝓕 : Type ?u.52628
𝕜 : Type ?u.52631
α : Type ?u.52634
ι : Type ?u.52637
κ : Type ?u.52640
E : Type u_1
F : Type ?u.52646
G : Type ?u.52649
inst✝³ : SeminormedGroup E
inst✝² : SeminormedGroup F
inst✝¹ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
inst✝ : ProperSpace E
⊢ Tendsto norm (cocompact E) atTop
Theorem: Nat.Prime.even_iff
File: Mathlib/Data/Nat/Prime.lean

tactic: rw [even_iff_two_dvd, prime_dvd_prime_iff_eq prime_two hp, eq_comm]
state_before: p : ℕ
hp : Prime p
⊢ Even p ↔ p = 2
Theorem: inner_self_re_eq_norm
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: conv_rhs => rw [← inner_self_ofReal_re]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1652408
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x : E
⊢ ↑re (inner x x) = ‖inner x x‖

tactic: symm
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1652408
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x : E
⊢ ↑re (inner x x) = ‖↑(↑re (inner x x))‖

tactic: exact norm_of_nonneg inner_self_nonneg
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1652408
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x : E
⊢ ‖↑(↑re (inner x x))‖ = ↑re (inner x x)
Theorem: AEMeasurable.inner
File: Mathlib/MeasureTheory/Function/SpecialFunctions/Inner.lean

tactic: refine' ⟨fun x => ⟪hf.mk f x, hg.mk g x⟫, hf.measurable_mk.inner hg.measurable_mk, _⟩
state_before: α : Type u_1
𝕜 : Type u_3
E : Type u_2
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : InnerProductSpace 𝕜 E
m : MeasurableSpace α
inst✝² : MeasurableSpace E
inst✝¹ : OpensMeasurableSpace E
inst✝ : TopologicalSpace.SecondCountableTopology E
μ : MeasureTheory.Measure α
f g : α → E
hf : AEMeasurable f
hg : AEMeasurable g
⊢ AEMeasurable fun x => Inner.inner (f x) (g x)

tactic: refine' hf.ae_eq_mk.mp (hg.ae_eq_mk.mono fun x hxg hxf => _)
state_before: α : Type u_1
𝕜 : Type u_3
E : Type u_2
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : InnerProductSpace 𝕜 E
m : MeasurableSpace α
inst✝² : MeasurableSpace E
inst✝¹ : OpensMeasurableSpace E
inst✝ : TopologicalSpace.SecondCountableTopology E
μ : MeasureTheory.Measure α
f g : α → E
hf : AEMeasurable f
hg : AEMeasurable g
⊢ (fun x => Inner.inner (f x) (g x)) =ᶠ[MeasureTheory.Measure.ae μ] fun x => Inner.inner (mk f hf x) (mk g hg x)

tactic: dsimp only
state_before: α : Type u_1
𝕜 : Type u_3
E : Type u_2
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : InnerProductSpace 𝕜 E
m : MeasurableSpace α
inst✝² : MeasurableSpace E
inst✝¹ : OpensMeasurableSpace E
inst✝ : TopologicalSpace.SecondCountableTopology E
μ : MeasureTheory.Measure α
f g : α → E
hf : AEMeasurable f
hg : AEMeasurable g
x : α
hxg : g x = mk g hg x
hxf : f x = mk f hf x
⊢ (fun x => Inner.inner (f x) (g x)) x = (fun x => Inner.inner (mk f hf x) (mk g hg x)) x

tactic: congr
state_before: α : Type u_1
𝕜 : Type u_3
E : Type u_2
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : InnerProductSpace 𝕜 E
m : MeasurableSpace α
inst✝² : MeasurableSpace E
inst✝¹ : OpensMeasurableSpace E
inst✝ : TopologicalSpace.SecondCountableTopology E
μ : MeasureTheory.Measure α
f g : α → E
hf : AEMeasurable f
hg : AEMeasurable g
x : α
hxg : g x = mk g hg x
hxf : f x = mk f hf x
⊢ Inner.inner (f x) (g x) = Inner.inner (mk f hf x) (mk g hg x)
Theorem: pow_bit0_nonneg
File: Mathlib/Algebra/GroupPower/Order.lean

tactic: rw [pow_bit0]
state_before: β : Type ?u.251747
A : Type ?u.251750
G : Type ?u.251753
M : Type ?u.251756
R : Type u_1
inst✝ : LinearOrderedRing R
a : R
n : ℕ
⊢ 0 ≤ a ^ bit0 n

tactic: exact mul_self_nonneg _
state_before: β : Type ?u.251747
A : Type ?u.251750
G : Type ?u.251753
M : Type ?u.251756
R : Type u_1
inst✝ : LinearOrderedRing R
a : R
n : ℕ
⊢ 0 ≤ a ^ n * a ^ n
Theorem: lp.norm_apply_le_norm
File: Mathlib/Analysis/NormedSpace/lpSpace.lean

tactic: rcases eq_or_ne p ∞ with (rfl | hp')
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
hp : p ≠ 0
f : { x // x ∈ lp E p }
i : α
⊢ ‖↑f i‖ ≤ ‖f‖

tactic: have hp'' : 0 < p.toReal := ENNReal.toReal_pos hp hp'
state_before: case inr
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
hp : p ≠ 0
f : { x // x ∈ lp E p }
i : α
hp' : p ≠ ⊤
⊢ ‖↑f i‖ ≤ ‖f‖

tactic: have : ∀ i, 0 ≤ ‖f i‖ ^ p.toReal := fun i => Real.rpow_nonneg_of_nonneg (norm_nonneg _) _
state_before: case inr
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
hp : p ≠ 0
f : { x // x ∈ lp E p }
i : α
hp' : p ≠ ⊤
hp'' : 0 < ENNReal.toReal p
⊢ ‖↑f i‖ ≤ ‖f‖

tactic: rw [← Real.rpow_le_rpow_iff (norm_nonneg _) (norm_nonneg' _) hp'']
state_before: case inr
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
hp : p ≠ 0
f : { x // x ∈ lp E p }
i : α
hp' : p ≠ ⊤
hp'' : 0 < ENNReal.toReal p
this : ∀ (i : α), 0 ≤ ‖↑f i‖ ^ ENNReal.toReal p
⊢ ‖↑f i‖ ≤ ‖f‖

tactic: convert le_hasSum (hasSum_norm hp'' f) i fun i _ => this i
state_before: case inr
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
hp : p ≠ 0
f : { x // x ∈ lp E p }
i : α
hp' : p ≠ ⊤
hp'' : 0 < ENNReal.toReal p
this : ∀ (i : α), 0 ≤ ‖↑f i‖ ^ ENNReal.toReal p
⊢ ‖↑f i‖ ^ ENNReal.toReal p ≤ ‖f‖ ^ ENNReal.toReal p

tactic: haveI : Nonempty α := ⟨i⟩
state_before: case inl
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
i : α
hp : ⊤ ≠ 0
f : { x // x ∈ lp E ⊤ }
⊢ ‖↑f i‖ ≤ ‖f‖

tactic: exact (isLUB_norm f).1 ⟨i, rfl⟩
state_before: case inl
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
i : α
hp : ⊤ ≠ 0
f : { x // x ∈ lp E ⊤ }
this : Nonempty α
⊢ ‖↑f i‖ ≤ ‖f‖
Theorem: Ring.inverse_unit
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

tactic: rw [inverse, dif_pos u.isUnit, IsUnit.unit_of_val_units]
state_before: α : Type ?u.5314
M₀ : Type u_1
G₀ : Type ?u.5320
M₀' : Type ?u.5323
G₀' : Type ?u.5326
F : Type ?u.5329
F' : Type ?u.5332
inst✝ : MonoidWithZero M₀
u : M₀ˣ
⊢ inverse ↑u = ↑u⁻¹
Theorem: Pell.xn_modEq_x4n_sub
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: rw [Nat.succ_mul]
state_before: a : ℕ
a1 : 1 < a
n j : ℕ
h : j ≤ 2 * n
⊢ 2 * n ≤ 2 * n

tactic: refine' @ModEq.trans _ _ 0 _ _ (by rw [add_comm]; exact (xn_modEq_x2n_sub _ h).symm)
state_before: a : ℕ
a1 : 1 < a
n j : ℕ
h h' : j ≤ 2 * n
⊢ xn a1 (4 * n - j) + xn a1 (2 * n - j) ≡ xn a1 j + xn a1 (2 * n - j) [MOD xn a1 n]

tactic: rw [show 4 * n = 2 * n + 2 * n from right_distrib 2 2 n, add_tsub_assoc_of_le h']
state_before: a : ℕ
a1 : 1 < a
n j : ℕ
h h' : j ≤ 2 * n
⊢ xn a1 (4 * n - j) + xn a1 (2 * n - j) ≡ 0 [MOD xn a1 n]

tactic: apply xn_modEq_x2n_add
state_before: a : ℕ
a1 : 1 < a
n j : ℕ
h h' : j ≤ 2 * n
⊢ xn a1 (2 * n + (2 * n - j)) + xn a1 (2 * n - j) ≡ 0 [MOD xn a1 n]

tactic: rw [add_comm]
state_before: a : ℕ
a1 : 1 < a
n j : ℕ
h h' : j ≤ 2 * n
⊢ 0 ≡ xn a1 j + xn a1 (2 * n - j) [MOD xn a1 n]

tactic: exact (xn_modEq_x2n_sub _ h).symm
state_before: a : ℕ
a1 : 1 < a
n j : ℕ
h h' : j ≤ 2 * n
⊢ 0 ≡ xn a1 (2 * n - j) + xn a1 j [MOD xn a1 n]
Theorem: Nat.ArithmeticFunction.cardFactors_eq_one_iff_prime
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: refine' ⟨fun h => _, fun h => List.length_eq_one.2 ⟨n, factors_prime h⟩⟩
state_before: R : Type ?u.553341
n : ℕ
⊢ ↑Ω n = 1 ↔ Prime n

tactic: cases n
state_before: R : Type ?u.553341
n : ℕ
h : ↑Ω n = 1
⊢ Prime n

tactic: rename_i n
state_before: case succ
R : Type ?u.553341
n✝ : ℕ
h : ↑Ω (succ n✝) = 1
⊢ Prime (succ n✝)

tactic: rcases List.length_eq_one.1 h with ⟨x, hx⟩
state_before: case succ
R : Type ?u.553341
n : ℕ
h : ↑Ω (succ n) = 1
⊢ Prime (succ n)

tactic: rw [← prod_factors n.succ_ne_zero, hx, List.prod_singleton]
state_before: case succ.intro
R : Type ?u.553341
n : ℕ
h : ↑Ω (succ n) = 1
x : ℕ
hx : factors (succ n) = [x]
⊢ Prime (succ n)

tactic: apply prime_of_mem_factors
state_before: case succ.intro
R : Type ?u.553341
n : ℕ
h : ↑Ω (succ n) = 1
x : ℕ
hx : factors (succ n) = [x]
⊢ Prime x

tactic: rw [hx, List.mem_singleton]
state_before: case succ.intro.h
R : Type ?u.553341
n : ℕ
h : ↑Ω (succ n) = 1
x : ℕ
hx : factors (succ n) = [x]
⊢ x ∈ factors ?succ.intro.n

case succ.intro.n
R : Type ?u.553341
n : ℕ
h : ↑Ω (succ n) = 1
x : ℕ
hx : factors (succ n) = [x]
⊢ ℕ

tactic: contrapose! h
state_before: case zero
R : Type ?u.553341
h : ↑Ω Nat.zero = 1
⊢ Prime Nat.zero

tactic: simp
state_before: case zero
R : Type ?u.553341
h : ¬Prime Nat.zero
⊢ ↑Ω Nat.zero ≠ 1
Theorem: MeasureTheory.memℒp_congr_ae
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: simp only [Memℒp, snorm_congr_ae hfg, aestronglyMeasurable_congr hfg]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.1830381
G : Type ?u.1830384
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f g : α → E
hfg : f =ᵐ[μ] g
⊢ Memℒp f p ↔ Memℒp g p
Theorem: MeasureTheory.lintegral_liminf_le'
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: simp only [liminf_eq_iSup_iInf_of_nat]
state_before: α : Type u_1
β : Type ?u.993590
γ : Type ?u.993593
δ : Type ?u.993596
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
h_meas : ∀ (n : ℕ), AEMeasurable (f n)
⊢ (∫⁻ (a : α), liminf (fun n => f n a) atTop ∂μ) = ∫⁻ (a : α), ⨆ (n : ℕ), ⨅ (i : ℕ) (_ : i ≥ n), f i a ∂μ
Theorem: Sum.traverse_map
File: Mathlib/Control/Traversable/Instances.lean

tactic: cases x <;> simp [Sum.traverse, id_map, functor_norm] <;> rfl
state_before: σ : Type u
F G : Type u → Type u
inst✝¹ : Applicative F
inst✝ : Applicative G
α β γ : Type u
g : α → β
f : β → G γ
x : σ ⊕ α
⊢ Sum.traverse f (g <$> x) = Sum.traverse (f ∘ g) x
Theorem: IsUnit.one_div_mul_cancel
File: Mathlib/Algebra/Hom/Units.lean

tactic: simp [h]
state_before: F : Type ?u.55248
G : Type ?u.55251
α : Type u_1
M : Type ?u.55257
N : Type ?u.55260
inst✝ : DivisionMonoid α
a b c : α
h : IsUnit a
⊢ 1 / a * a = 1
Theorem: PowerSeries.coeff_zero_mul_X
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: simp
state_before: R : Type u_1
inst✝ : Semiring R
φ : PowerSeries R
⊢ ↑(coeff R 0) (φ * X) = 0
Theorem: support_finRotate
File: Mathlib/GroupTheory/Perm/Fin.lean

tactic: ext
state_before: n : ℕ
⊢ support (finRotate (n + 2)) = Finset.univ

tactic: simp
state_before: case a
n : ℕ
a✝ : Fin (n + 2)
⊢ a✝ ∈ support (finRotate (n + 2)) ↔ a✝ ∈ Finset.univ