tasksource/leandojo huggingface dataset:
Theorem: Int.lt_add_of_sub_right_lt
File: Std/Data/Int/Lemmas.lean

tactic: have h := Int.add_lt_add_right h c
state_before: a b c : Int
h : a - c < b
⊢ a < b + c

tactic: rwa [Int.sub_add_cancel] at h
state_before: a b c : Int
h✝ : a - c < b
h : a - c + c < b + c
⊢ a < b + c
Theorem: GeneralizedContinuedFraction.squashGCF_nth_of_lt
File: Mathlib/Algebra/ContinuedFractions/ConvergentsEquiv.lean

tactic: simp only [squashGCF, squashSeq_nth_of_lt m_lt_n, Nat.add_eq, add_zero]
state_before: K : Type u_1
n : ℕ
g : GeneralizedContinuedFraction K
s : Stream'.Seq (Pair K)
inst✝ : DivisionRing K
m : ℕ
m_lt_n : m < n
⊢ Stream'.Seq.get? (squashGCF g (n + 1)).s m = Stream'.Seq.get? g.s m
Theorem: Finset.insert_erase
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [mem_insert, mem_erase, or_and_left, dec_em, true_and_iff]
state_before: α : Type u_1
β : Type ?u.211528
γ : Type ?u.211531
inst✝ : DecidableEq α
s✝ t u v : Finset α
a✝ b a : α
s : Finset α
h : a ∈ s
x : α
⊢ x ∈ insert a (erase s a) ↔ x ∈ s

tactic: apply or_iff_right_of_imp
state_before: α : Type u_1
β : Type ?u.211528
γ : Type ?u.211531
inst✝ : DecidableEq α
s✝ t u v : Finset α
a✝ b a : α
s : Finset α
h : a ∈ s
x : α
⊢ x = a ∨ x ∈ s ↔ x ∈ s

tactic: rintro rfl
state_before: case ha
α : Type u_1
β : Type ?u.211528
γ : Type ?u.211531
inst✝ : DecidableEq α
s✝ t u v : Finset α
a✝ b a : α
s : Finset α
h : a ∈ s
x : α
⊢ x = a → x ∈ s

tactic: exact h
state_before: case ha
α : Type u_1
β : Type ?u.211528
γ : Type ?u.211531
inst✝ : DecidableEq α
s✝ t u v : Finset α
a b : α
s : Finset α
x : α
h : x ∈ s
⊢ x ∈ s
Theorem: Colex.sum_two_pow_le_iff_lt
File: Mathlib/Combinatorics/Colex.lean

tactic: rw [le_iff_le_iff_lt_iff_lt, sum_two_pow_lt_iff_lt]
state_before: α : Type ?u.87959
A B : Finset ℕ
⊢ ∑ i in A, 2 ^ i ≤ ∑ i in B, 2 ^ i ↔ toColex A ≤ toColex B
Theorem: Equiv.Perm.SameCycle.apply_eq_self_iff
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: rw [← hi, ← mul_apply, ← zpow_one_add, add_comm, zpow_add_one, mul_apply,
  (f ^ i).injective.eq_iff]
state_before: ι : Type ?u.41748
α : Type u_1
β : Type ?u.41754
f g : Perm α
p : α → Prop
x y z : α
x✝ : SameCycle f x y
i : ℤ
hi : ↑(f ^ i) x = y
⊢ ↑f x = x ↔ ↑f y = y
Theorem: balancedCoreAux_maximal
File: Mathlib/Analysis/LocallyConvex/BalancedCoreHull.lean

tactic: refine' fun x hx => mem_balancedCoreAux_iff.2 fun r hr => _
state_before: 𝕜 : Type u_2
E : Type u_1
ι : Type ?u.58007
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
h : t ⊆ s
ht : Balanced 𝕜 t
⊢ t ⊆ balancedCoreAux 𝕜 s

tactic: rw [mem_smul_set_iff_inv_smul_mem₀ (norm_pos_iff.mp <| zero_lt_one.trans_le hr)]
state_before: 𝕜 : Type u_2
E : Type u_1
ι : Type ?u.58007
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
h : t ⊆ s
ht : Balanced 𝕜 t
x : E
hx : x ∈ t
r : 𝕜
hr : 1 ≤ ‖r‖
⊢ x ∈ r • s

tactic: refine' h (ht.smul_mem _ hx)
state_before: 𝕜 : Type u_2
E : Type u_1
ι : Type ?u.58007
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
h : t ⊆ s
ht : Balanced 𝕜 t
x : E
hx : x ∈ t
r : 𝕜
hr : 1 ≤ ‖r‖
⊢ r⁻¹ • x ∈ s

tactic: rw [norm_inv]
state_before: 𝕜 : Type u_2
E : Type u_1
ι : Type ?u.58007
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
h : t ⊆ s
ht : Balanced 𝕜 t
x : E
hx : x ∈ t
r : 𝕜
hr : 1 ≤ ‖r‖
⊢ ‖r⁻¹‖ ≤ 1

tactic: exact inv_le_one hr
state_before: 𝕜 : Type u_2
E : Type u_1
ι : Type ?u.58007
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
h : t ⊆ s
ht : Balanced 𝕜 t
x : E
hx : x ∈ t
r : 𝕜
hr : 1 ≤ ‖r‖
⊢ ‖r‖⁻¹ ≤ 1
Theorem: Multiset.rel_zero_left
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [Rel_iff]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.441085
δ : Type ?u.441088
r : α → β → Prop
p : γ → δ → Prop
b : Multiset β
⊢ Rel r 0 b ↔ b = 0

tactic: simp
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.441085
δ : Type ?u.441088
r : α → β → Prop
p : γ → δ → Prop
b : Multiset β
⊢ (0 = 0 ∧ b = 0 ∨
      Exists fun {a} =>
        Exists fun {b_1} =>
          Exists fun {as} => Exists fun {bs} => r a b_1 ∧ Rel r as bs ∧ 0 = a ::ₘ as ∧ b = b_1 ::ₘ bs) ↔
    b = 0
Theorem: Int.exists_least_of_bdd
File: Mathlib/Data/Int/LeastGreatest.lean

tactic: let ⟨b , Hb⟩ := Hbdd
state_before: P : ℤ → Prop
inst✝ : DecidablePred P
Hbdd : ∃ b, ∀ (z : ℤ), P z → b ≤ z
Hinh : ∃ z, P z
⊢ ∃ lb, P lb ∧ ∀ (z : ℤ), P z → lb ≤ z

tactic: let ⟨lb , H⟩ := leastOfBdd b Hb Hinh
state_before: P : ℤ → Prop
inst✝ : DecidablePred P
Hbdd : ∃ b, ∀ (z : ℤ), P z → b ≤ z
Hinh : ∃ z, P z
b : ℤ
Hb : ∀ (z : ℤ), P z → b ≤ z
⊢ ∃ lb, P lb ∧ ∀ (z : ℤ), P z → lb ≤ z

tactic: exact ⟨lb , H⟩
state_before: P : ℤ → Prop
inst✝ : DecidablePred P
Hbdd : ∃ b, ∀ (z : ℤ), P z → b ≤ z
Hinh : ∃ z, P z
b : ℤ
Hb : ∀ (z : ℤ), P z → b ≤ z
lb : ℤ
H : P lb ∧ ∀ (z : ℤ), P z → lb ≤ z
⊢ ∃ lb, P lb ∧ ∀ (z : ℤ), P z → lb ≤ z
Theorem: Polynomial.zero_isRoot_of_coeff_zero_eq_zero
File: Mathlib/Data/Polynomial/Eval.lean

tactic: rwa [coeff_zero_eq_eval_zero] at hp
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝ : Semiring R
p✝ q r : R[X]
x : R
p : R[X]
hp : coeff p 0 = 0
⊢ IsRoot p 0
Theorem: finrank_euclideanSpace_fin
File: Mathlib/Analysis/InnerProductSpace/PiL2.lean

tactic: simp
state_before: ι : Type ?u.77081
ι' : Type ?u.77084
𝕜 : Type u_1
inst✝⁹ : IsROrC 𝕜
E : Type ?u.77093
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : InnerProductSpace 𝕜 E
E' : Type ?u.77113
inst✝⁶ : NormedAddCommGroup E'
inst✝⁵ : InnerProductSpace 𝕜 E'
F : Type ?u.77131
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
F' : Type ?u.77151
inst✝² : NormedAddCommGroup F'
inst✝¹ : InnerProductSpace ℝ F'
inst✝ : Fintype ι
n : ℕ
⊢ FiniteDimensional.finrank 𝕜 (EuclideanSpace 𝕜 (Fin n)) = n
Theorem: Convex.mem_toCone
File: Mathlib/Analysis/Convex/Cone/Basic.lean

tactic: simp only [toCone, ConvexCone.mem_mk, mem_iUnion, mem_smul_set, eq_comm, exists_prop]
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.162171
G : Type ?u.162174
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s : Set E
hs : Convex 𝕜 s
x : E
⊢ x ∈ toCone s hs ↔ ∃ c, 0 < c ∧ ∃ y, y ∈ s ∧ c • y = x
Theorem: List.sublistsLen_length
File: Mathlib/Data/List/Sublists.lean

tactic: simp only [length, sublistsLen_succ_cons, sublistsLen_length, map,
  sublistsLen_of_length_lt (lt_succ_self _), nil_append]
state_before: α : Type u
β : Type v
γ : Type w
a : α
l : List α
⊢ sublistsLen (length (a :: l)) (a :: l) = [a :: l]
Theorem: List.map_fst_add_enumFrom_eq_enumFrom
File: Mathlib/Data/List/Basic.lean

tactic: induction' l with hd tl IH generalizing n k
state_before: ι : Type ?u.449078
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
n k : ℕ
⊢ map (Prod.map (fun x => x + n) id) (enumFrom k l) = enumFrom (n + k) l

tactic: simp [enumFrom]
state_before: case nil
ι : Type ?u.449078
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
n✝ k✝ n k : ℕ
⊢ map (Prod.map (fun x => x + n) id) (enumFrom k []) = enumFrom (n + k) []

tactic: simp only [enumFrom, map, zero_add, Prod.map_mk, id.def, eq_self_iff_true, true_and_iff]
state_before: case cons
ι : Type ?u.449078
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
n✝ k✝ : ℕ
hd : α
tl : List α
IH : ∀ (n k : ℕ), map (Prod.map (fun x => x + n) id) (enumFrom k tl) = enumFrom (n + k) tl
n k : ℕ
⊢ map (Prod.map (fun x => x + n) id) (enumFrom k (hd :: tl)) = enumFrom (n + k) (hd :: tl)

tactic: simp [IH, add_comm n k, add_assoc, add_left_comm]
state_before: case cons
ι : Type ?u.449078
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
n✝ k✝ : ℕ
hd : α
tl : List α
IH : ∀ (n k : ℕ), map (Prod.map (fun x => x + n) id) (enumFrom k tl) = enumFrom (n + k) tl
n k : ℕ
⊢ (k + n, hd) :: map (Prod.map (fun x => x + n) id) (enumFrom (k + 1) tl) = (n + k, hd) :: enumFrom (n + k + 1) tl
Theorem: Hyperreal.infinite_abs_iff
File: Mathlib/Data/Real/Hyperreal.lean

tactic: cases le_total 0 x <;> simp [*, abs_of_nonneg, abs_of_nonpos, infinite_neg]
state_before: x : ℝ*
⊢ Infinite (abs x) ↔ Infinite x
Theorem: ContDiffWithinAt.contDiffAt
File: Mathlib/Analysis/Calculus/ContDiffDef.lean

tactic: rwa [ContDiffAt, ← contDiffWithinAt_inter hx, univ_inter]
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
h : ContDiffWithinAt 𝕜 n f s x
hx : s ∈ 𝓝 x
⊢ ContDiffAt 𝕜 n f x
Theorem: MvPowerSeries.coeff_add_monomial_mul
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: rw [coeff_monomial_mul, if_pos, add_tsub_cancel_left]
state_before: σ : Type u_2
R : Type u_1
inst✝ : Semiring R
m n : σ →₀ ℕ
φ ψ : MvPowerSeries σ R
a : R
⊢ ↑(coeff R (m + n)) (↑(monomial R m) a * φ) = a * ↑(coeff R n) φ

tactic: exact le_add_right le_rfl
state_before: case hc
σ : Type u_2
R : Type u_1
inst✝ : Semiring R
m n : σ →₀ ℕ
φ ψ : MvPowerSeries σ R
a : R
⊢ m ≤ m + n
Theorem: LieSubmodule.lcs_le_iff
File: Mathlib/Algebra/Lie/Nilpotent.lean

tactic: convert lcs_add_le_iff (R := R) (L := L) (M := M) 0 k
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N N₁ N₂ : LieSubmodule R L M
k : ℕ
⊢ lcs k N₁ ≤ N₂ ↔ N₁ ≤ ucs k N₂

tactic: rw [zero_add]
state_before: case h.e'_1.h.e'_3.h.e'_10
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N N₁ N₂ : LieSubmodule R L M
k : ℕ
⊢ k = 0 + k
Theorem: Polynomial.reverse_eq_zero
File: Mathlib/Data/Polynomial/Reverse.lean

tactic: simp [reverse]
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
⊢ reverse f = 0 ↔ f = 0
Theorem: MeasureTheory.integral_inter_add_diff₀
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

tactic: rw [← Measure.restrict_inter_add_diff₀ s ht, integral_add_measure]
state_before: α : Type u_1
β : Type ?u.8904
E : Type u_2
F : Type ?u.8910
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
l l' : Filter α
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
ht : NullMeasurableSet t
hfs : IntegrableOn f s
⊢ ((∫ (x : α) in s ∩ t, f x ∂μ) + ∫ (x : α) in s \ t, f x ∂μ) = ∫ (x : α) in s, f x ∂μ

tactic: exact Integrable.mono_measure hfs (Measure.restrict_mono (inter_subset_left _ _) le_rfl)
state_before: case hμ
α : Type u_1
β : Type ?u.8904
E : Type u_2
F : Type ?u.8910
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
l l' : Filter α
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
ht : NullMeasurableSet t
hfs : IntegrableOn f s
⊢ Integrable fun x => f x

tactic: exact Integrable.mono_measure hfs (Measure.restrict_mono (diff_subset _ _) le_rfl)
state_before: case hν
α : Type u_1
β : Type ?u.8904
E : Type u_2
F : Type ?u.8910
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
l l' : Filter α
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
ht : NullMeasurableSet t
hfs : IntegrableOn f s
⊢ Integrable fun x => f x
Theorem: disjoint_iSup_iff
File: Mathlib/Order/CompleteBooleanAlgebra.lean

tactic: simpa only [disjoint_comm] using @iSup_disjoint_iff
state_before: α : Type u
β : Type v
ι : Sort w
κ : ι → Sort ?u.8073
inst✝ : Frame α
s t : Set α
a b : α
f : ι → α
⊢ Disjoint a (⨆ (i : ι), f i) ↔ ∀ (i : ι), Disjoint a (f i)
Theorem: RatFunc.intDegree_C
File: Mathlib/FieldTheory/RatFunc.lean

tactic: rw [intDegree, num_C, natDegree_C, denom_C, natDegree_one, sub_self]
state_before: K : Type u
inst✝ : Field K
k : K
⊢ intDegree (↑C k) = 0
Theorem: MeasureTheory.Measure.add_haar_closedBall_eq_add_haar_ball
File: Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean

tactic: by_cases h : r < 0
state_before: E : Type u_1
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace ℝ E
inst✝⁷ : MeasurableSpace E
inst✝⁶ : BorelSpace E
inst✝⁵ : FiniteDimensional ℝ E
μ : Measure E
inst✝⁴ : IsAddHaarMeasure μ
F : Type ?u.2014882
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
s : Set E
inst✝ : Nontrivial E
x : E
r : ℝ
⊢ ↑↑μ (closedBall x r) = ↑↑μ (ball x r)

tactic: push_neg at h
state_before: case neg
E : Type u_1
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace ℝ E
inst✝⁷ : MeasurableSpace E
inst✝⁶ : BorelSpace E
inst✝⁵ : FiniteDimensional ℝ E
μ : Measure E
inst✝⁴ : IsAddHaarMeasure μ
F : Type ?u.2014882
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
s : Set E
inst✝ : Nontrivial E
x : E
r : ℝ
h : ¬r < 0
⊢ ↑↑μ (closedBall x r) = ↑↑μ (ball x r)

tactic: rw [add_haar_closedBall μ x h, add_haar_ball μ x h]
state_before: case neg
E : Type u_1
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace ℝ E
inst✝⁷ : MeasurableSpace E
inst✝⁶ : BorelSpace E
inst✝⁵ : FiniteDimensional ℝ E
μ : Measure E
inst✝⁴ : IsAddHaarMeasure μ
F : Type ?u.2014882
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
s : Set E
inst✝ : Nontrivial E
x : E
r : ℝ
h : 0 ≤ r
⊢ ↑↑μ (closedBall x r) = ↑↑μ (ball x r)

tactic: rw [Metric.closedBall_eq_empty.mpr h, Metric.ball_eq_empty.mpr h.le]
state_before: case pos
E : Type u_1
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace ℝ E
inst✝⁷ : MeasurableSpace E
inst✝⁶ : BorelSpace E
inst✝⁵ : FiniteDimensional ℝ E
μ : Measure E
inst✝⁴ : IsAddHaarMeasure μ
F : Type ?u.2014882
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
s : Set E
inst✝ : Nontrivial E
x : E
r : ℝ
h : r < 0
⊢ ↑↑μ (closedBall x r) = ↑↑μ (ball x r)
Theorem: pochhammer_ne_zero_eval_zero
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

tactic: simp [pochhammer_eval_zero, h]
state_before: S : Type u
inst✝ : Semiring S
n : ℕ
h : n ≠ 0
⊢ eval 0 (pochhammer S n) = 0
Theorem: Part.inter_get_eq
File: Mathlib/Data/Part.lean

tactic: simp [inter_def]
state_before: α : Type u_1
β : Type ?u.87424
γ : Type ?u.87427
inst✝ : Inter α
a b : Part α
hab : (a ∩ b).Dom
⊢ get (a ∩ b) hab = get a (_ : a.Dom) ∩ get b (_ : b.Dom)

tactic: aesop
state_before: α : Type u_1
β : Type ?u.87424
γ : Type ?u.87427
inst✝ : Inter α
a b : Part α
hab : (a ∩ b).Dom
⊢ get (Part.bind a fun y => map (fun x => y ∩ x) b) (_ : (Part.bind a fun y => map (fun x => y ∩ x) b).Dom) =
    get a (_ : a.Dom) ∩ get b (_ : b.Dom)
Theorem: CompleteLattice.Independent.subtype_ne_bot_le_finrank_aux
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: suffices Cardinal.lift.{v} (#{ i // p i ≠ ⊥ }) ≤ Cardinal.lift.{v} (finrank K V : Cardinal.{w}) by
  rwa [Cardinal.lift_le] at this
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₂
inst✝ : FiniteDimensional K V
ι : Type w
p : ι → Submodule K V
hp : CompleteLattice.Independent p
⊢ (#{ i // p i ≠ ⊥ }) ≤ ↑(finrank K V)

tactic: calc
  Cardinal.lift.{v} (#{ i // p i ≠ ⊥ }) ≤ Cardinal.lift.{w} (Module.rank K V) :=
    hp.subtype_ne_bot_le_rank
  _ = Cardinal.lift.{w} (finrank K V : Cardinal.{v}) := by rw [finrank_eq_rank]
  _ = Cardinal.lift.{v} (finrank K V : Cardinal.{w}) := by simp
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₂
inst✝ : FiniteDimensional K V
ι : Type w
p : ι → Submodule K V
hp : CompleteLattice.Independent p
⊢ lift (#{ i // p i ≠ ⊥ }) ≤ lift ↑(finrank K V)

tactic: rwa [Cardinal.lift_le] at this
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₂
inst✝ : FiniteDimensional K V
ι : Type w
p : ι → Submodule K V
hp : CompleteLattice.Independent p
this : lift (#{ i // p i ≠ ⊥ }) ≤ lift ↑(finrank K V)
⊢ (#{ i // p i ≠ ⊥ }) ≤ ↑(finrank K V)

tactic: rw [finrank_eq_rank]
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₂
inst✝ : FiniteDimensional K V
ι : Type w
p : ι → Submodule K V
hp : CompleteLattice.Independent p
⊢ lift (Module.rank K V) = lift ↑(finrank K V)

tactic: simp
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₂
inst✝ : FiniteDimensional K V
ι : Type w
p : ι → Submodule K V
hp : CompleteLattice.Independent p
⊢ lift ↑(finrank K V) = lift ↑(finrank K V)
Theorem: Nat.bitCasesOn_bit
File: Mathlib/Data/Nat/Bits.lean

tactic: rw [bodd_bit, div2_bit]
state_before: n✝ : ℕ
C : ℕ → Sort u
H : (b : Bool) → (n : ℕ) → C (bit b n)
b : Bool
n : ℕ
⊢ HEq (H (bodd (bit b n)) (div2 (bit b n))) (H b n)
Theorem: MeasureTheory.tendsto_measure_iInter
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [measure_iInter_eq_iInf hs (directed_of_sup hm) hf]
state_before: α : Type u_2
β : Type ?u.58576
γ : Type ?u.58579
δ : Type ?u.58582
ι : Type u_1
R : Type ?u.58588
R' : Type ?u.58591
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
inst✝¹ : Countable ι
inst✝ : SemilatticeSup ι
s : ι → Set α
hs : ∀ (n : ι), MeasurableSet (s n)
hm : Antitone s
hf : ∃ i, ↑↑μ (s i) ≠ ⊤
⊢ Tendsto (↑↑μ ∘ s) atTop (𝓝 (↑↑μ (⋂ (n : ι), s n)))

tactic: exact tendsto_atTop_iInf fun n m hnm => measure_mono <| hm hnm
state_before: α : Type u_2
β : Type ?u.58576
γ : Type ?u.58579
δ : Type ?u.58582
ι : Type u_1
R : Type ?u.58588
R' : Type ?u.58591
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
inst✝¹ : Countable ι
inst✝ : SemilatticeSup ι
s : ι → Set α
hs : ∀ (n : ι), MeasurableSet (s n)
hm : Antitone s
hf : ∃ i, ↑↑μ (s i) ≠ ⊤
⊢ Tendsto (↑↑μ ∘ s) atTop (𝓝 (⨅ (i : ι), ↑↑μ (s i)))
Theorem: Function.update_inf
File: Mathlib/Order/Lattice.lean

tactic: obtain rfl | hji := eq_or_ne j i <;> simp [update_noteq, *]
state_before: α : Type u
β : Type v
ι : Type u_2
π : ι → Type u_1
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → SemilatticeInf (π i)
f : (i : ι) → π i
i : ι
a b : π i
j : ι
⊢ update f i (a ⊓ b) j = (update f i a ⊓ update f i b) j
Theorem: IsPGroup.exists_fixed_point_of_prime_dvd_card_of_fixed_point
File: Mathlib/GroupTheory/PGroup.lean

tactic: cases nonempty_fintype (fixedPoints G α)
state_before: p : ℕ
G : Type u_2
inst✝² : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
α : Type u_1
inst✝¹ : MulAction G α
inst✝ : Fintype α
hpα : p ∣ card α
a : α
ha : a ∈ fixedPoints G α
⊢ ∃ b, b ∈ fixedPoints G α ∧ a ≠ b

tactic: have hpf : p ∣ card (fixedPoints G α) :=
  Nat.modEq_zero_iff_dvd.mp ((hG.card_modEq_card_fixedPoints α).symm.trans hpα.modEq_zero_nat)
state_before: case intro
p : ℕ
G : Type u_2
inst✝² : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
α : Type u_1
inst✝¹ : MulAction G α
inst✝ : Fintype α
hpα : p ∣ card α
a : α
ha : a ∈ fixedPoints G α
val✝ : Fintype ↑(fixedPoints G α)
⊢ ∃ b, b ∈ fixedPoints G α ∧ a ≠ b

tactic: have hα : 1 < card (fixedPoints G α) :=
  (Fact.out (p := p.Prime)).one_lt.trans_le (Nat.le_of_dvd (card_pos_iff.2 ⟨⟨a, ha⟩⟩) hpf)
state_before: case intro
p : ℕ
G : Type u_2
inst✝² : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
α : Type u_1
inst✝¹ : MulAction G α
inst✝ : Fintype α
hpα : p ∣ card α
a : α
ha : a ∈ fixedPoints G α
val✝ : Fintype ↑(fixedPoints G α)
hpf : p ∣ card ↑(fixedPoints G α)
⊢ ∃ b, b ∈ fixedPoints G α ∧ a ≠ b

tactic: exact
  let ⟨⟨b, hb⟩, hba⟩ := exists_ne_of_one_lt_card hα ⟨a, ha⟩
  ⟨b, hb, fun hab => hba (by simp_rw [hab])⟩
state_before: case intro
p : ℕ
G : Type u_2
inst✝² : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
α : Type u_1
inst✝¹ : MulAction G α
inst✝ : Fintype α
hpα : p ∣ card α
a : α
ha : a ∈ fixedPoints G α
val✝ : Fintype ↑(fixedPoints G α)
hpf : p ∣ card ↑(fixedPoints G α)
hα : 1 < card ↑(fixedPoints G α)
⊢ ∃ b, b ∈ fixedPoints G α ∧ a ≠ b

tactic: simp_rw [hab]
state_before: p : ℕ
G : Type u_2
inst✝² : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
α : Type u_1
inst✝¹ : MulAction G α
inst✝ : Fintype α
hpα : p ∣ card α
a : α
ha : a ∈ fixedPoints G α
val✝ : Fintype ↑(fixedPoints G α)
hpf : p ∣ card ↑(fixedPoints G α)
hα : 1 < card ↑(fixedPoints G α)
b : α
hb : b ∈ fixedPoints G α
hba : { val := b, property := hb } ≠ { val := a, property := ha }
hab : a = b
⊢ { val := b, property := hb } = { val := a, property := ha }
Theorem: CstarRing.norm_coe_unitary_mul
File: Mathlib/Analysis/NormedSpace/Star/Basic.lean

tactic: nontriviality E
state_before: 𝕜 : Type ?u.77873
E : Type u_1
α : Type ?u.77879
inst✝² : NormedRing E
inst✝¹ : StarRing E
inst✝ : CstarRing E
U : { x // x ∈ unitary E }
A : E
⊢ ‖↑U * A‖ = ‖A‖

tactic: refine' le_antisymm _ _
state_before: 𝕜 : Type ?u.77873
E : Type u_1
α : Type ?u.77879
inst✝² : NormedRing E
inst✝¹ : StarRing E
inst✝ : CstarRing E
U : { x // x ∈ unitary E }
A : E
✝ : Nontrivial E
⊢ ‖↑U * A‖ = ‖A‖

tactic: calc
  _ ≤ ‖(U : E)‖ * ‖A‖ := norm_mul_le _ _
  _ = ‖A‖ := by rw [norm_coe_unitary, one_mul]
state_before: case refine'_1
𝕜 : Type ?u.77873
E : Type u_1
α : Type ?u.77879
inst✝² : NormedRing E
inst✝¹ : StarRing E
inst✝ : CstarRing E
U : { x // x ∈ unitary E }
A : E
✝ : Nontrivial E
⊢ ‖↑U * A‖ ≤ ‖A‖

tactic: rw [norm_coe_unitary, one_mul]
state_before: 𝕜 : Type ?u.77873
E : Type u_1
α : Type ?u.77879
inst✝² : NormedRing E
inst✝¹ : StarRing E
inst✝ : CstarRing E
U : { x // x ∈ unitary E }
A : E
✝ : Nontrivial E
⊢ ‖↑U‖ * ‖A‖ = ‖A‖

tactic: calc
  _ = ‖(U : E)⋆ * U * A‖ := by rw [unitary.coe_star_mul_self U, one_mul]
  _ ≤ ‖(U : E)⋆‖ * ‖(U : E) * A‖ := by
    rw [mul_assoc]
    exact norm_mul_le _ _
  _ = ‖(U : E) * A‖ := by rw [norm_star, norm_coe_unitary, one_mul]
state_before: case refine'_2
𝕜 : Type ?u.77873
E : Type u_1
α : Type ?u.77879
inst✝² : NormedRing E
inst✝¹ : StarRing E
inst✝ : CstarRing E
U : { x // x ∈ unitary E }
A : E
✝ : Nontrivial E
⊢ ‖A‖ ≤ ‖↑U * A‖

tactic: rw [unitary.coe_star_mul_self U, one_mul]
state_before: 𝕜 : Type ?u.77873
E : Type u_1
α : Type ?u.77879
inst✝² : NormedRing E
inst✝¹ : StarRing E
inst✝ : CstarRing E
U : { x // x ∈ unitary E }
A : E
✝ : Nontrivial E
⊢ ‖A‖ = ‖(↑U)⋆ * ↑U * A‖

tactic: rw [mul_assoc]
state_before: 𝕜 : Type ?u.77873
E : Type u_1
α : Type ?u.77879
inst✝² : NormedRing E
inst✝¹ : StarRing E
inst✝ : CstarRing E
U : { x // x ∈ unitary E }
A : E
✝ : Nontrivial E
⊢ ‖(↑U)⋆ * ↑U * A‖ ≤ ‖(↑U)⋆‖ * ‖↑U * A‖

tactic: exact norm_mul_le _ _
state_before: 𝕜 : Type ?u.77873
E : Type u_1
α : Type ?u.77879
inst✝² : NormedRing E
inst✝¹ : StarRing E
inst✝ : CstarRing E
U : { x // x ∈ unitary E }
A : E
✝ : Nontrivial E
⊢ ‖(↑U)⋆ * (↑U * A)‖ ≤ ‖(↑U)⋆‖ * ‖↑U * A‖

tactic: rw [norm_star, norm_coe_unitary, one_mul]
state_before: 𝕜 : Type ?u.77873
E : Type u_1
α : Type ?u.77879
inst✝² : NormedRing E
inst✝¹ : StarRing E
inst✝ : CstarRing E
U : { x // x ∈ unitary E }
A : E
✝ : Nontrivial E
⊢ ‖(↑U)⋆‖ * ‖↑U * A‖ = ‖↑U * A‖
Theorem: Antivary.sum_smul_eq_sum_comp_perm_smul_iff
File: Mathlib/Algebra/Order/Rearrangement.lean

tactic: simp [(hfg.antivaryOn _).sum_smul_eq_sum_comp_perm_smul_iff fun _ _ ↦ mem_univ _]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝⁴ : LinearOrderedRing α
inst✝³ : LinearOrderedAddCommGroup β
inst✝² : Module α β
inst✝¹ : OrderedSMul α β
s : Finset ι
σ : Perm ι
f : ι → α
g : ι → β
inst✝ : Fintype ι
hfg : Antivary f g
⊢ ∑ i : ι, f (↑σ i) • g i = ∑ i : ι, f i • g i ↔ Antivary (f ∘ ↑σ) g
Theorem: Set.zero_smul_set
File: Mathlib/Data/Set/Pointwise/SMul.lean

tactic: simp only [← image_smul, image_eta, zero_smul, h.image_const, singleton_zero]
state_before: F : Type ?u.91013
α : Type u_2
β : Type u_1
γ : Type ?u.91022
inst✝² : Zero α
inst✝¹ : Zero β
inst✝ : SMulWithZero α β
s✝ : Set α
t s : Set β
h : Set.Nonempty s
⊢ 0 • s = 0
Theorem: Monotone.monotone_iterate_of_le_map
File: Mathlib/Order/Iterate.lean

tactic: rw [iterate_succ_apply]
state_before: α : Type u_1
inst✝ : Preorder α
f : α → α
x : α
hf : Monotone f
hx : x ≤ f x
n : ℕ
⊢ (f^[n]) x ≤ (f^[n + 1]) x

tactic: exact hf.iterate n hx
state_before: α : Type u_1
inst✝ : Preorder α
f : α → α
x : α
hf : Monotone f
hx : x ≤ f x
n : ℕ
⊢ (f^[n]) x ≤ (f^[n]) (f x)