tasksource/leandojo huggingface dataset:
Theorem: Matrix.adjugate_fin_two
File: Mathlib/LinearAlgebra/Matrix/Adjugate.lean

tactic: ext (i 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 (Fin 2) (Fin 2) α
⊢ adjugate A = ↑of ![![A 1 1, -A 0 1], ![-A 1 0, A 0 0]]

tactic: rw [adjugate_apply, det_fin_two]
state_before: case a.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 (Fin 2) (Fin 2) α
i j : Fin 2
⊢ adjugate A i j = ↑of ![![A 1 1, -A 0 1], ![-A 1 0, A 0 0]] i j

tactic: fin_cases i <;> fin_cases j <;>
  simp [one_mul, Fin.one_eq_zero_iff, Pi.single_eq_same, MulZeroClass.mul_zero, sub_zero,
    Pi.single_eq_of_ne, Ne.def, not_false_iff, updateRow_self, updateRow_ne, cons_val_zero,
    of_apply, Nat.succ_succ_ne_one, Pi.single_eq_of_ne, updateRow_self, Pi.single_eq_of_ne,
    Ne.def, Fin.zero_eq_one_iff, Nat.succ_succ_ne_one, not_false_iff, updateRow_ne,
    Fin.one_eq_zero_iff, MulZeroClass.zero_mul, Pi.single_eq_same, one_mul, zero_sub, of_apply,
    cons_val', cons_val_fin_one, cons_val_one, head_fin_const, neg_inj, eq_self_iff_true,
    cons_val_zero, head_cons, mul_one]
state_before: case a.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 (Fin 2) (Fin 2) α
i j : Fin 2
⊢ updateRow A j (Pi.single i 1) 0 0 * updateRow A j (Pi.single i 1) 1 1 -
      updateRow A j (Pi.single i 1) 0 1 * updateRow A j (Pi.single i 1) 1 0 =
    ↑of ![![A 1 1, -A 0 1], ![-A 1 0, A 0 0]] i j
Theorem: Cardinal.mk_le_aleph0_iff
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [countable_iff_nonempty_embedding, aleph0, ← lift_uzero (#α), lift_mk_le']
state_before: α β : Type u
⊢ (#α) ≤ ℵ₀ ↔ Countable α
Theorem: Finset.image₂_inter_right
File: Mathlib/Data/Finset/NAry.lean

tactic: push_cast
state_before: α : Type u_2
α' : Type ?u.41366
β : Type u_1
β' : Type ?u.41372
γ : Type u_3
γ' : Type ?u.41378
δ : Type ?u.41381
δ' : Type ?u.41384
ε : Type ?u.41387
ε' : Type ?u.41390
ζ : Type ?u.41393
ζ' : Type ?u.41396
ν : Type ?u.41399
inst✝⁸ : DecidableEq α'
inst✝⁷ : DecidableEq β'
inst✝⁶ : DecidableEq γ
inst✝⁵ : DecidableEq γ'
inst✝⁴ : DecidableEq δ
inst✝³ : DecidableEq δ'
inst✝² : DecidableEq ε
inst✝¹ : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
inst✝ : DecidableEq β
hf : Injective2 f
⊢ ↑(image₂ f s (t ∩ t')) = ↑(image₂ f s t ∩ image₂ f s t')

tactic: exact image2_inter_right hf
state_before: α : Type u_2
α' : Type ?u.41366
β : Type u_1
β' : Type ?u.41372
γ : Type u_3
γ' : Type ?u.41378
δ : Type ?u.41381
δ' : Type ?u.41384
ε : Type ?u.41387
ε' : Type ?u.41390
ζ : Type ?u.41393
ζ' : Type ?u.41396
ν : Type ?u.41399
inst✝⁸ : DecidableEq α'
inst✝⁷ : DecidableEq β'
inst✝⁶ : DecidableEq γ
inst✝⁵ : DecidableEq γ'
inst✝⁴ : DecidableEq δ
inst✝³ : DecidableEq δ'
inst✝² : DecidableEq ε
inst✝¹ : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
inst✝ : DecidableEq β
hf : Injective2 f
⊢ image2 f (↑s) (↑t ∩ ↑t') = image2 f ↑s ↑t ∩ image2 f ↑s ↑t'
Theorem: Dfinsupp.support_erase
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: ext j
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
i : ι
f : Π₀ (i : ι), β i
⊢ support (erase i f) = Finset.erase (support f) i

tactic: by_cases h1 : j = i
state_before: case a
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
i : ι
f : Π₀ (i : ι), β i
j : ι
⊢ j ∈ support (erase i f) ↔ j ∈ Finset.erase (support f) i

tactic: simp [h1]
state_before: case pos
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
i : ι
f : Π₀ (i : ι), β i
j : ι
h1 : j = i
⊢ j ∈ support (erase i f) ↔ j ∈ Finset.erase (support f) i

case neg
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
i : ι
f : Π₀ (i : ι), β i
j : ι
h1 : ¬j = i
⊢ j ∈ support (erase i f) ↔ j ∈ Finset.erase (support f) i

tactic: by_cases h2 : f j ≠ 0 <;> simp at h2 <;> simp [h1, h2]
state_before: case neg
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
i : ι
f : Π₀ (i : ι), β i
j : ι
h1 : ¬j = i
⊢ j ∈ support (erase i f) ↔ j ∈ Finset.erase (support f) i
Theorem: map_inv_int_cast_smul
File: Mathlib/Algebra/Module/Basic.lean

tactic: obtain ⟨n, rfl | rfl⟩ := z.eq_nat_or_neg
state_before: α : Type ?u.198898
R✝ : Type ?u.198901
k : Type ?u.198904
S✝ : Type ?u.198907
M : Type u_1
M₂ : Type u_2
M₃ : Type ?u.198916
ι : Type ?u.198919
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M₂
F : Type u_3
inst✝⁴ : AddMonoidHomClass F M M₂
f : F
R : Type u_4
S : Type u_5
inst✝³ : DivisionRing R
inst✝² : DivisionRing S
inst✝¹ : Module R M
inst✝ : Module S M₂
z : ℤ
x : M
⊢ ↑f ((↑z)⁻¹ • x) = (↑z)⁻¹ • ↑f x

tactic: rw [Int.cast_Nat_cast, Int.cast_Nat_cast, map_inv_nat_cast_smul _ R S]
state_before: case intro.inl
α : Type ?u.198898
R✝ : Type ?u.198901
k : Type ?u.198904
S✝ : Type ?u.198907
M : Type u_1
M₂ : Type u_2
M₃ : Type ?u.198916
ι : Type ?u.198919
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M₂
F : Type u_3
inst✝⁴ : AddMonoidHomClass F M M₂
f : F
R : Type u_4
S : Type u_5
inst✝³ : DivisionRing R
inst✝² : DivisionRing S
inst✝¹ : Module R M
inst✝ : Module S M₂
x : M
n : ℕ
⊢ ↑f ((↑↑n)⁻¹ • x) = (↑↑n)⁻¹ • ↑f x

tactic: simp_rw [Int.cast_neg, Int.cast_Nat_cast, inv_neg, neg_smul, map_neg,
  map_inv_nat_cast_smul _ R S]
state_before: case intro.inr
α : Type ?u.198898
R✝ : Type ?u.198901
k : Type ?u.198904
S✝ : Type ?u.198907
M : Type u_1
M₂ : Type u_2
M₃ : Type ?u.198916
ι : Type ?u.198919
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M₂
F : Type u_3
inst✝⁴ : AddMonoidHomClass F M M₂
f : F
R : Type u_4
S : Type u_5
inst✝³ : DivisionRing R
inst✝² : DivisionRing S
inst✝¹ : Module R M
inst✝ : Module S M₂
x : M
n : ℕ
⊢ ↑f ((↑(-↑n))⁻¹ • x) = (↑(-↑n))⁻¹ • ↑f x
Theorem: Submodule.span_span_coe_preimage
File: Mathlib/LinearAlgebra/Span.lean

tactic: refine' span_induction' (p := fun x hx ↦ (⟨x, hx⟩ : span R s) ∈ span R (Subtype.val ⁻¹' s))
  (fun x' hx' ↦ subset_span hx') _ (fun x _ y _ ↦ _) (fun r x _ ↦ _) hx
state_before: R : Type u_2
R₂ : Type ?u.30116
K : Type ?u.30119
M : Type u_1
M₂ : Type ?u.30125
V : Type ?u.30128
S : Type ?u.30131
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
x✝² : M
p p' : Submodule R M
inst✝² : Semiring R₂
σ₁₂ : R →+* R₂
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R₂ M₂
s t : Set M
x✝¹ : { x // x ∈ ↑(span R s) }
x : M
hx : x ∈ ↑(span R s)
x✝ : { val := x, property := hx } ∈ ⊤
⊢ { val := x, property := hx } ∈ span R (Subtype.val ⁻¹' s)

tactic: exact zero_mem _
state_before: case refine'_1
R : Type u_2
R₂ : Type ?u.30116
K : Type ?u.30119
M : Type u_1
M₂ : Type ?u.30125
V : Type ?u.30128
S : Type ?u.30131
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
x✝² : M
p p' : Submodule R M
inst✝² : Semiring R₂
σ₁₂ : R →+* R₂
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R₂ M₂
s t : Set M
x✝¹ : { x // x ∈ ↑(span R s) }
x : M
hx : x ∈ ↑(span R s)
x✝ : { val := x, property := hx } ∈ ⊤
⊢ (fun x hx => { val := x, property := hx } ∈ span R (Subtype.val ⁻¹' s)) 0 (_ : 0 ∈ span R s)

tactic: exact add_mem
state_before: case refine'_2
R : Type u_2
R₂ : Type ?u.30116
K : Type ?u.30119
M : Type u_1
M₂ : Type ?u.30125
V : Type ?u.30128
S : Type ?u.30131
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
x✝⁵ : M
p p' : Submodule R M
inst✝² : Semiring R₂
σ₁₂ : R →+* R₂
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R₂ M₂
s t : Set M
x✝⁴ : { x // x ∈ ↑(span R s) }
x✝³ : M
hx : x✝³ ∈ ↑(span R s)
x✝² : { val := x✝³, property := hx } ∈ ⊤
x : M
x✝¹ : x ∈ span R s
y : M
x✝ : y ∈ span R s
⊢ (fun x hx => { val := x, property := hx } ∈ span R (Subtype.val ⁻¹' s)) x x✝¹ →
    (fun x hx => { val := x, property := hx } ∈ span R (Subtype.val ⁻¹' s)) y x✝ →
      (fun x hx => { val := x, property := hx } ∈ span R (Subtype.val ⁻¹' s)) (x + y) (_ : x + y ∈ span R s)

tactic: exact smul_mem _ _
state_before: case refine'_3
R : Type u_2
R₂ : Type ?u.30116
K : Type ?u.30119
M : Type u_1
M₂ : Type ?u.30125
V : Type ?u.30128
S : Type ?u.30131
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
x✝⁴ : M
p p' : Submodule R M
inst✝² : Semiring R₂
σ₁₂ : R →+* R₂
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R₂ M₂
s t : Set M
x✝³ : { x // x ∈ ↑(span R s) }
x✝² : M
hx : x✝² ∈ ↑(span R s)
x✝¹ : { val := x✝², property := hx } ∈ ⊤
r : R
x : M
x✝ : x ∈ span R s
⊢ (fun x hx => { val := x, property := hx } ∈ span R (Subtype.val ⁻¹' s)) x x✝ →
    (fun x hx => { val := x, property := hx } ∈ span R (Subtype.val ⁻¹' s)) (r • x) (_ : r • x ∈ span R s)
Theorem: MeasureTheory.Measure.haarMeasure_unique
File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

tactic: rw [haarMeasure_self, div_one]
state_before: G : Type u_1
inst✝⁸ : Group G
inst✝⁷ : TopologicalSpace G
inst✝⁶ : T2Space G
inst✝⁵ : TopologicalGroup G
inst✝⁴ : MeasurableSpace G
inst✝³ : BorelSpace G
inst✝² : SecondCountableTopology G
μ : Measure G
inst✝¹ : SigmaFinite μ
inst✝ : IsMulLeftInvariant μ
K₀ : PositiveCompacts G
⊢ (↑↑μ ↑K₀ / ↑↑(haarMeasure K₀) ↑K₀) • haarMeasure K₀ = ↑↑μ ↑K₀ • haarMeasure K₀
Theorem: ENNReal.one_lt_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: cases x
state_before: x : ℝ≥0∞
z : ℝ
hx : 1 < x
hz : 0 < z
⊢ 1 < x ^ z

tactic: simp [top_rpow_of_pos hz]
state_before: case none
z : ℝ
hz : 0 < z
hx : 1 < none
⊢ 1 < none ^ z

tactic: simp only [some_eq_coe, one_lt_coe_iff] at hx
state_before: case some
z : ℝ
hz : 0 < z
val✝ : ℝ≥0
hx : 1 < Option.some val✝
⊢ 1 < Option.some val✝ ^ z

tactic: simp [coe_rpow_of_nonneg _ (le_of_lt hz), NNReal.one_lt_rpow hx hz]
state_before: case some
z : ℝ
hz : 0 < z
val✝ : ℝ≥0
hx : 1 < val✝
⊢ 1 < Option.some val✝ ^ z
Theorem: Polynomial.toLaurent_C_mul_eq
File: Mathlib/Data/Polynomial/Laurent.lean

tactic: simp only [_root_.map_mul, Polynomial.toLaurent_C]
state_before: R : Type u_1
inst✝ : Semiring R
r : R
f : R[X]
⊢ ↑toLaurent (↑Polynomial.C r * f) = ↑C r * ↑toLaurent f
Theorem: BilinForm.ext
File: Mathlib/LinearAlgebra/BilinearForm.lean

tactic: funext
state_before: R : Type u_1
M : Type u_2
inst✝¹⁴ : Semiring R
inst✝¹³ : AddCommMonoid M
inst✝¹² : Module R M
R₁ : Type ?u.72414
M₁ : Type ?u.72417
inst✝¹¹ : Ring R₁
inst✝¹⁰ : AddCommGroup M₁
inst✝⁹ : Module R₁ M₁
R₂ : Type ?u.73026
M₂ : Type ?u.73029
inst✝⁸ : CommSemiring R₂
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : Module R₂ M₂
R₃ : Type ?u.73216
M₃ : Type ?u.73219
inst✝⁵ : CommRing R₃
inst✝⁴ : AddCommGroup M₃
inst✝³ : Module R₃ M₃
V : Type ?u.73807
K : Type ?u.73810
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
D : BilinForm R M
D₁ : BilinForm R₁ M₁
H : ∀ (x y : M), bilin B x y = bilin D x y
⊢ B.bilin = D.bilin

tactic: exact H _ _
state_before: case h.h
R : Type u_1
M : Type u_2
inst✝¹⁴ : Semiring R
inst✝¹³ : AddCommMonoid M
inst✝¹² : Module R M
R₁ : Type ?u.72414
M₁ : Type ?u.72417
inst✝¹¹ : Ring R₁
inst✝¹⁰ : AddCommGroup M₁
inst✝⁹ : Module R₁ M₁
R₂ : Type ?u.73026
M₂ : Type ?u.73029
inst✝⁸ : CommSemiring R₂
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : Module R₂ M₂
R₃ : Type ?u.73216
M₃ : Type ?u.73219
inst✝⁵ : CommRing R₃
inst✝⁴ : AddCommGroup M₃
inst✝³ : Module R₃ M₃
V : Type ?u.73807
K : Type ?u.73810
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
D : BilinForm R M
D₁ : BilinForm R₁ M₁
H : ∀ (x y : M), bilin B x y = bilin D x y
x✝¹ x✝ : M
⊢ bilin B x✝¹ x✝ = bilin D x✝¹ x✝
Theorem: uniqueDiffOn_Ico
File: Mathlib/Analysis/Calculus/TangentCone.lean

tactic: simp only [interior_Ico, nonempty_Ioo, hab]
state_before: 𝕜 : Type ?u.181211
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type ?u.181217
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type ?u.181312
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type ?u.181402
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
x y : E
s t : Set E
a b : ℝ
hab : a < b
⊢ Set.Nonempty (interior (Ico a b))

tactic: simp only [Ico_eq_empty hab, uniqueDiffOn_empty]
state_before: 𝕜 : Type ?u.181211
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type ?u.181217
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type ?u.181312
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type ?u.181402
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
x y : E
s t : Set E
a b : ℝ
hab : ¬a < b
⊢ UniqueDiffOn ℝ (Ico a b)
Theorem: Multiset.noncommFoldr_coe
File: Mathlib/Data/Finset/NoncommProd.lean

tactic: simp only [noncommFoldr, coe_foldr, coe_attach, List.attach, Function.comp]
state_before: F : Type ?u.664
ι : Type ?u.667
α : Type u_1
β : Type u_2
γ : Type ?u.676
f : α → β → β
op : α → α → α
l : List α
comm : Set.Pairwise {x | x ∈ ↑l} fun x y => ∀ (b : β), f x (f y b) = f y (f x b)
b : β
⊢ noncommFoldr f (↑l) comm b = List.foldr f b l

tactic: rw [← List.foldr_map]
state_before: F : Type ?u.664
ι : Type ?u.667
α : Type u_1
β : Type u_2
γ : Type ?u.676
f : α → β → β
op : α → α → α
l : List α
comm : Set.Pairwise {x | x ∈ ↑l} fun x y => ∀ (b : β), f x (f y b) = f y (f x b)
b : β
⊢ List.foldr (fun x => f ↑x) b (List.pmap Subtype.mk l (_ : ∀ (x : α), x ∈ l → x ∈ l)) = List.foldr f b l

tactic: simp [List.map_pmap, List.pmap_eq_map]
state_before: F : Type ?u.664
ι : Type ?u.667
α : Type u_1
β : Type u_2
γ : Type ?u.676
f : α → β → β
op : α → α → α
l : List α
comm : Set.Pairwise {x | x ∈ ↑l} fun x y => ∀ (b : β), f x (f y b) = f y (f x b)
b : β
⊢ List.foldr f b (List.map (fun x => ↑x) (List.pmap Subtype.mk l (_ : ∀ (x : α), x ∈ l → x ∈ l))) = List.foldr f b l
Theorem: liouvilleWith_one
File: Mathlib/NumberTheory/Liouville/LiouvilleWith.lean

tactic: use 2
state_before: x : ℝ
⊢ LiouvilleWith 1 x

tactic: refine ((eventually_gt_atTop 0).mono fun n hn => ?_).frequently
state_before: x : ℝ
⊢ ∃ᶠ (n : ℕ) in atTop, ∃ m, x ≠ ↑m / ↑n ∧ abs (x - ↑m / ↑n) < 2 / ↑n ^ 1

tactic: have hn' : (0 : ℝ) < n := by simpa
state_before: x : ℝ
n : ℕ
hn : 0 < n
⊢ ∃ m, x ≠ ↑m / ↑n ∧ abs (x - ↑m / ↑n) < 2 / ↑n ^ 1

tactic: have : x < ↑(⌊x * ↑n⌋ + 1) / ↑n := by
  rw [lt_div_iff hn', Int.cast_add, Int.cast_one];
  exact Int.lt_floor_add_one _
state_before: x : ℝ
n : ℕ
hn : 0 < n
hn' : 0 < ↑n
⊢ ∃ m, x ≠ ↑m / ↑n ∧ abs (x - ↑m / ↑n) < 2 / ↑n ^ 1

tactic: refine ⟨⌊x * n⌋ + 1, this.ne, ?_⟩
state_before: x : ℝ
n : ℕ
hn : 0 < n
hn' : 0 < ↑n
this : x < ↑(⌊x * ↑n⌋ + 1) / ↑n
⊢ ∃ m, x ≠ ↑m / ↑n ∧ abs (x - ↑m / ↑n) < 2 / ↑n ^ 1

tactic: rw [abs_sub_comm, abs_of_pos (sub_pos.2 this), rpow_one, sub_lt_iff_lt_add',
  add_div_eq_mul_add_div _ _ hn'.ne', div_lt_div_right hn']
state_before: x : ℝ
n : ℕ
hn : 0 < n
hn' : 0 < ↑n
this : x < ↑(⌊x * ↑n⌋ + 1) / ↑n
⊢ abs (x - ↑(⌊x * ↑n⌋ + 1) / ↑n) < 2 / ↑n ^ 1

tactic: convert add_lt_add_right ((Int.floor_le (x * n)).trans_lt (lt_add_one _)) 1 using 1 <;>
push_cast <;> ring
state_before: x : ℝ
n : ℕ
hn : 0 < n
hn' : 0 < ↑n
this : x < ↑(⌊x * ↑n⌋ + 1) / ↑n
⊢ ↑(⌊x * ↑n⌋ + 1) < x * ↑n + 2

tactic: simpa
state_before: x : ℝ
n : ℕ
hn : 0 < n
⊢ 0 < ↑n

tactic: rw [lt_div_iff hn', Int.cast_add, Int.cast_one]
state_before: x : ℝ
n : ℕ
hn : 0 < n
hn' : 0 < ↑n
⊢ x < ↑(⌊x * ↑n⌋ + 1) / ↑n

tactic: exact Int.lt_floor_add_one _
state_before: x : ℝ
n : ℕ
hn : 0 < n
hn' : 0 < ↑n
⊢ x * ↑n < ↑⌊x * ↑n⌋ + 1
Theorem: Finset.prod_add_prod_eq
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: classical
  simp_rw [prod_eq_mul_prod_diff_singleton hi, ← h1, right_distrib]
  congr 2 <;> apply prod_congr rfl <;> simpa
state_before: ι : Type ?u.810222
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝ : CommSemiring β
s : Finset α
i : α
f g h : α → β
hi : i ∈ s
h1 : g i + h i = f i
h2 : ∀ (j : α), j ∈ s → j ≠ i → g j = f j
h3 : ∀ (j : α), j ∈ s → j ≠ i → h j = f j
⊢ ∏ i in s, g i + ∏ i in s, h i = ∏ i in s, f i

tactic: simp_rw [prod_eq_mul_prod_diff_singleton hi, ← h1, right_distrib]
state_before: ι : Type ?u.810222
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝ : CommSemiring β
s : Finset α
i : α
f g h : α → β
hi : i ∈ s
h1 : g i + h i = f i
h2 : ∀ (j : α), j ∈ s → j ≠ i → g j = f j
h3 : ∀ (j : α), j ∈ s → j ≠ i → h j = f j
⊢ ∏ i in s, g i + ∏ i in s, h i = ∏ i in s, f i

tactic: congr 2 <;> apply prod_congr rfl <;> simpa
state_before: ι : Type ?u.810222
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝ : CommSemiring β
s : Finset α
i : α
f g h : α → β
hi : i ∈ s
h1 : g i + h i = f i
h2 : ∀ (j : α), j ∈ s → j ≠ i → g j = f j
h3 : ∀ (j : α), j ∈ s → j ≠ i → h j = f j
⊢ g i * ∏ i in s \ {i}, g i + h i * ∏ i in s \ {i}, h i = g i * ∏ i in s \ {i}, f i + h i * ∏ i in s \ {i}, f i
Theorem: PadicInt.mem_span_pow_iff_le_valuation
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

tactic: rw [Ideal.mem_span_singleton]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n : ℕ
⊢ x ∈ Ideal.span {↑p ^ n} ↔ ↑n ≤ valuation x

tactic: constructor
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n : ℕ
⊢ ↑p ^ n ∣ x ↔ ↑n ≤ valuation x

tactic: rintro ⟨c, rfl⟩
state_before: case mp
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n : ℕ
⊢ ↑p ^ n ∣ x → ↑n ≤ valuation x

tactic: suffices c ≠ 0 by
  rw [valuation_p_pow_mul _ _ this, le_add_iff_nonneg_right]
  apply valuation_nonneg
state_before: case mp.intro
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
c : ℤ_[p]
hx : ↑p ^ n * c ≠ 0
⊢ ↑n ≤ valuation (↑p ^ n * c)

tactic: contrapose! hx
state_before: case mp.intro
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
c : ℤ_[p]
hx : ↑p ^ n * c ≠ 0
⊢ c ≠ 0

tactic: rw [hx, MulZeroClass.mul_zero]
state_before: case mp.intro
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
c : ℤ_[p]
hx : c = 0
⊢ ↑p ^ n * c = 0

tactic: rw [valuation_p_pow_mul _ _ this, le_add_iff_nonneg_right]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
c : ℤ_[p]
hx : ↑p ^ n * c ≠ 0
this : c ≠ 0
⊢ ↑n ≤ valuation (↑p ^ n * c)

tactic: apply valuation_nonneg
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
c : ℤ_[p]
hx : ↑p ^ n * c ≠ 0
this : c ≠ 0
⊢ 0 ≤ valuation c

tactic: nth_rewrite 2 [unitCoeff_spec hx]
state_before: case mpr
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n : ℕ
⊢ ↑n ≤ valuation x → ↑p ^ n ∣ x

tactic: lift x.valuation to ℕ using x.valuation_nonneg with k
state_before: case mpr
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n : ℕ
⊢ ↑n ≤ valuation x → ↑p ^ n ∣ ↑(unitCoeff hx) * ↑p ^ Int.natAbs (valuation x)

tactic: simp only [Int.natAbs_ofNat, Units.isUnit, IsUnit.dvd_mul_left, Int.ofNat_le]
state_before: case mpr.intro
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n k : ℕ
⊢ ↑n ≤ ↑k → ↑p ^ n ∣ ↑(unitCoeff hx) * ↑p ^ Int.natAbs ↑k

tactic: intro H
state_before: case mpr.intro
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n k : ℕ
⊢ n ≤ k → ↑p ^ n ∣ ↑p ^ k

tactic: obtain ⟨k, rfl⟩ := Nat.exists_eq_add_of_le H
state_before: case mpr.intro
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n k : ℕ
H : n ≤ k
⊢ ↑p ^ n ∣ ↑p ^ k

tactic: simp only [pow_add, dvd_mul_right]
state_before: case mpr.intro.intro
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n k : ℕ
H : n ≤ n + k
⊢ ↑p ^ n ∣ ↑p ^ (n + k)
Theorem: SimpleGraph.Walk.IsEulerian.mem_edges_iff
File: Mathlib/Combinatorics/SimpleGraph/Trails.lean

tactic: simpa using (h e he).ge
state_before: V : Type u_1
G : SimpleGraph V
inst✝ : DecidableEq V
u v : V
p : Walk G u v
h : IsEulerian p
e : Sym2 V
he : e ∈ edgeSet G
⊢ e ∈ edges p
Theorem: Complex.cos_nat_mul_two_pi_add_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: simpa only [cos_zero] using (cos_periodic.nat_mul n).add_antiperiod_eq cos_antiperiodic
state_before: n : ℕ
⊢ cos (↑n * (2 * ↑π) + ↑π) = -1
Theorem: Fin.pred_le_pred_iff
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [← succ_le_succ_iff, succ_pred, succ_pred]
state_before: n✝ m n : ℕ
a b : Fin (Nat.succ n)
ha : a ≠ 0
hb : b ≠ 0
⊢ pred a ha ≤ pred b hb ↔ a ≤ b
Theorem: LinearMap.ext_ring
File: Mathlib/Algebra/Module/LinearMap.lean

tactic: rw [← mul_one x, ← smul_eq_mul, f.map_smulₛₗ, g.map_smulₛₗ, h]
state_before: R : Type u_1
R₁ : Type ?u.219990
R₂ : Type ?u.219993
R₃ : Type ?u.219996
k : Type ?u.219999
S : Type u_2
S₃ : Type ?u.220005
T : Type ?u.220008
M : Type ?u.220011
M₁ : Type ?u.220014
M₂ : Type ?u.220017
M₃ : Type u_3
N₁ : Type ?u.220023
N₂ : Type ?u.220026
N₃ : Type ?u.220029
ι : Type ?u.220032
inst✝¹¹ : Semiring R
inst✝¹⁰ : Semiring S
inst✝⁹ : AddCommMonoid M
inst✝⁸ : AddCommMonoid M₁
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : AddCommMonoid M₃
inst✝⁵ : AddCommMonoid N₁
inst✝⁴ : AddCommMonoid N₂
inst✝³ : AddCommMonoid N₃
inst✝² : Module R M
inst✝¹ : Module R M₂
inst✝ : Module S M₃
σ : R →+* S
fₗ gₗ : M →ₗ[R] M₂
f✝ g✝ : M →ₛₗ[σ] M₃
f g : R →ₛₗ[σ] M₃
h : ↑f 1 = ↑g 1
x : R
⊢ ↑f x = ↑g x
Theorem: MeasureTheory.snorm_mono_nnnorm_ae
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: simp only [snorm]
state_before: α : Type u_1
E : Type ?u.1428197
F : Type u_2
G : Type u_3
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
g : α → G
h : ∀ᵐ (x : α) ∂μ, ‖f x‖₊ ≤ ‖g x‖₊
⊢ snorm f p μ ≤ snorm g p μ

tactic: split_ifs
state_before: α : Type u_1
E : Type ?u.1428197
F : Type u_2
G : Type u_3
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
g : α → G
h : ∀ᵐ (x : α) ∂μ, ‖f x‖₊ ≤ ‖g x‖₊
⊢ (if p = 0 then 0 else if p = ⊤ then snormEssSup f μ else snorm' f (ENNReal.toReal p) μ) ≤
    if p = 0 then 0 else if p = ⊤ then snormEssSup g μ else snorm' g (ENNReal.toReal p) μ

tactic: exact le_rfl
state_before: case inl
α : Type u_1
E : Type ?u.1428197
F : Type u_2
G : Type u_3
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
g : α → G
h : ∀ᵐ (x : α) ∂μ, ‖f x‖₊ ≤ ‖g x‖₊
h✝ : p = 0
⊢ 0 ≤ 0

tactic: exact essSup_mono_ae (h.mono fun x hx => ENNReal.coe_le_coe.mpr hx)
state_before: case inr.inl
α : Type u_1
E : Type ?u.1428197
F : Type u_2
G : Type u_3
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
g : α → G
h : ∀ᵐ (x : α) ∂μ, ‖f x‖₊ ≤ ‖g x‖₊
h✝¹ : ¬p = 0
h✝ : p = ⊤
⊢ snormEssSup f μ ≤ snormEssSup g μ

tactic: exact snorm'_mono_nnnorm_ae ENNReal.toReal_nonneg h
state_before: case inr.inr
α : Type u_1
E : Type ?u.1428197
F : Type u_2
G : Type u_3
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
g : α → G
h : ∀ᵐ (x : α) ∂μ, ‖f x‖₊ ≤ ‖g x‖₊
h✝¹ : ¬p = 0
h✝ : ¬p = ⊤
⊢ snorm' f (ENNReal.toReal p) μ ≤ snorm' g (ENNReal.toReal p) μ
Theorem: CategoryTheory.Limits.biproduct.fromSubtype_eq_lift
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

tactic: simp
state_before: J : Type w
C : Type u
inst✝⁴ : Category C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
⊢ ∀ (j : J),
    fromSubtype f p ≫ π f j =
      (lift fun j => if h : p j then π (Subtype.restrict p f) { val := j, property := h } else 0) ≫ π f j