tasksource/leandojo huggingface dataset:
Theorem: isExtreme_sInter
File: Mathlib/Analysis/Convex/Extreme.lean

tactic: obtain ⟨B, hB⟩ := hF
state_before: 𝕜 : Type u_2
E : Type u_1
F✝ : Type ?u.4264
ι : Type ?u.4267
π : ι → Type ?u.4272
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
A B C : Set E
x : E
F : Set (Set E)
hF : Set.Nonempty F
hAF : ∀ (B : Set E), B ∈ F → IsExtreme 𝕜 A B
⊢ IsExtreme 𝕜 A (⋂₀ F)

tactic: refine' ⟨(sInter_subset_of_mem hB).trans (hAF B hB).1, fun x₁ hx₁A x₂ hx₂A x hxF hx ↦ _⟩
state_before: case intro
𝕜 : Type u_2
E : Type u_1
F✝ : Type ?u.4264
ι : Type ?u.4267
π : ι → Type ?u.4272
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
A B✝ C : Set E
x : E
F : Set (Set E)
hAF : ∀ (B : Set E), B ∈ F → IsExtreme 𝕜 A B
B : Set E
hB : B ∈ F
⊢ IsExtreme 𝕜 A (⋂₀ F)

tactic: simp_rw [mem_sInter] at hxF⊢
state_before: case intro
𝕜 : Type u_2
E : Type u_1
F✝ : Type ?u.4264
ι : Type ?u.4267
π : ι → Type ?u.4272
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
A B✝ C : Set E
x✝ : E
F : Set (Set E)
hAF : ∀ (B : Set E), B ∈ F → IsExtreme 𝕜 A B
B : Set E
hB : B ∈ F
x₁ : E
hx₁A : x₁ ∈ A
x₂ : E
hx₂A : x₂ ∈ A
x : E
hxF : x ∈ ⋂₀ F
hx : x ∈ openSegment 𝕜 x₁ x₂
⊢ x₁ ∈ ⋂₀ F ∧ x₂ ∈ ⋂₀ F

tactic: have h := fun B hB ↦ (hAF B hB).2 hx₁A hx₂A (hxF B hB) hx
state_before: case intro
𝕜 : Type u_2
E : Type u_1
F✝ : Type ?u.4264
ι : Type ?u.4267
π : ι → Type ?u.4272
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
A B✝ C : Set E
x✝ : E
F : Set (Set E)
hAF : ∀ (B : Set E), B ∈ F → IsExtreme 𝕜 A B
B : Set E
hB : B ∈ F
x₁ : E
hx₁A : x₁ ∈ A
x₂ : E
hx₂A : x₂ ∈ A
x : E
hx : x ∈ openSegment 𝕜 x₁ x₂
hxF : ∀ (t : Set E), t ∈ F → x ∈ t
⊢ (∀ (t : Set E), t ∈ F → x₁ ∈ t) ∧ ∀ (t : Set E), t ∈ F → x₂ ∈ t

tactic: exact ⟨fun B hB ↦ (h B hB).1, fun B hB ↦ (h B hB).2⟩
state_before: case intro
𝕜 : Type u_2
E : Type u_1
F✝ : Type ?u.4264
ι : Type ?u.4267
π : ι → Type ?u.4272
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
A B✝ C : Set E
x✝ : E
F : Set (Set E)
hAF : ∀ (B : Set E), B ∈ F → IsExtreme 𝕜 A B
B : Set E
hB : B ∈ F
x₁ : E
hx₁A : x₁ ∈ A
x₂ : E
hx₂A : x₂ ∈ A
x : E
hx : x ∈ openSegment 𝕜 x₁ x₂
hxF : ∀ (t : Set E), t ∈ F → x ∈ t
h : ∀ (B : Set E), B ∈ F → x₁ ∈ B ∧ x₂ ∈ B
⊢ (∀ (t : Set E), t ∈ F → x₁ ∈ t) ∧ ∀ (t : Set E), t ∈ F → x₂ ∈ t
Theorem: Polynomial.Chebyshev.map_T
File: Mathlib/RingTheory/Polynomial/Chebyshev.lean

tactic: simp only [T_zero, Polynomial.map_one]
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
⊢ map f (T R 0) = T S 0

tactic: simp only [T_one, map_X]
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
⊢ map f (T R 1) = T S 1

tactic: simp only [T_add_two, Polynomial.map_mul, Polynomial.map_sub, map_X, Polynomial.map_add,
  Polynomial.map_one, Polynomial.map_ofNat, map_T f (n + 1), map_T f n]
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
n : ℕ
⊢ map f (T R (n + 2)) = T S (n + 2)
Theorem: Int.min_le_right
File: Std/Data/Int/Lemmas.lean

tactic: rw [Int.min_def]
state_before: a b : Int
⊢ min a b ≤ b

tactic: split <;> simp [*]
state_before: a b : Int
⊢ (if a ≤ b then a else b) ≤ b
Theorem: Matrix.isHermitian_iff_isSymmetric
File: Mathlib/LinearAlgebra/Matrix/Hermitian.lean

tactic: rw [LinearMap.IsSymmetric, (PiLp.equiv 2 fun _ : n => α).symm.surjective.forall₂]
state_before: α : Type u_2
β : Type ?u.119376
m : Type ?u.119379
n : Type u_1
A✝ : Matrix n n α
inst✝³ : IsROrC α
inst✝² : IsROrC β
inst✝¹ : Fintype n
inst✝ : DecidableEq n
A : Matrix n n α
⊢ IsHermitian A ↔ LinearMap.IsSymmetric (↑toEuclideanLin A)

tactic: simp only [toEuclideanLin_piLp_equiv_symm, EuclideanSpace.inner_piLp_equiv_symm, toLin'_apply,
  star_mulVec, dotProduct_mulVec]
state_before: α : Type u_2
β : Type ?u.119376
m : Type ?u.119379
n : Type u_1
A✝ : Matrix n n α
inst✝³ : IsROrC α
inst✝² : IsROrC β
inst✝¹ : Fintype n
inst✝ : DecidableEq n
A : Matrix n n α
⊢ IsHermitian A ↔
    ∀ (x₁ x₂ : n → α),
      inner (↑(↑toEuclideanLin A) (↑(PiLp.equiv 2 fun x => α).symm x₁)) (↑(PiLp.equiv 2 fun x => α).symm x₂) =
        inner (↑(PiLp.equiv 2 fun x => α).symm x₁) (↑(↑toEuclideanLin A) (↑(PiLp.equiv 2 fun x => α).symm x₂))

tactic: constructor
state_before: α : Type u_2
β : Type ?u.119376
m : Type ?u.119379
n : Type u_1
A✝ : Matrix n n α
inst✝³ : IsROrC α
inst✝² : IsROrC β
inst✝¹ : Fintype n
inst✝ : DecidableEq n
A : Matrix n n α
⊢ IsHermitian A ↔ ∀ (x₁ x₂ : n → α), vecMul (star x₁) Aᴴ ⬝ᵥ x₂ = vecMul (star x₁) A ⬝ᵥ x₂

tactic: rintro (h : Aᴴ = A) x y
state_before: case mp
α : Type u_2
β : Type ?u.119376
m : Type ?u.119379
n : Type u_1
A✝ : Matrix n n α
inst✝³ : IsROrC α
inst✝² : IsROrC β
inst✝¹ : Fintype n
inst✝ : DecidableEq n
A : Matrix n n α
⊢ IsHermitian A → ∀ (x₁ x₂ : n → α), vecMul (star x₁) Aᴴ ⬝ᵥ x₂ = vecMul (star x₁) A ⬝ᵥ x₂

tactic: rw [h]
state_before: case mp
α : Type u_2
β : Type ?u.119376
m : Type ?u.119379
n : Type u_1
A✝ : Matrix n n α
inst✝³ : IsROrC α
inst✝² : IsROrC β
inst✝¹ : Fintype n
inst✝ : DecidableEq n
A : Matrix n n α
h : Aᴴ = A
x y : n → α
⊢ vecMul (star x) Aᴴ ⬝ᵥ y = vecMul (star x) A ⬝ᵥ y

tactic: intro h
state_before: case mpr
α : Type u_2
β : Type ?u.119376
m : Type ?u.119379
n : Type u_1
A✝ : Matrix n n α
inst✝³ : IsROrC α
inst✝² : IsROrC β
inst✝¹ : Fintype n
inst✝ : DecidableEq n
A : Matrix n n α
⊢ (∀ (x₁ x₂ : n → α), vecMul (star x₁) Aᴴ ⬝ᵥ x₂ = vecMul (star x₁) A ⬝ᵥ x₂) → IsHermitian A

tactic: ext (i j)
state_before: case mpr
α : Type u_2
β : Type ?u.119376
m : Type ?u.119379
n : Type u_1
A✝ : Matrix n n α
inst✝³ : IsROrC α
inst✝² : IsROrC β
inst✝¹ : Fintype n
inst✝ : DecidableEq n
A : Matrix n n α
h : ∀ (x₁ x₂ : n → α), vecMul (star x₁) Aᴴ ⬝ᵥ x₂ = vecMul (star x₁) A ⬝ᵥ x₂
⊢ IsHermitian A

tactic: simpa only [(Pi.single_star i 1).symm, ← star_mulVec, mul_one, dotProduct_single,
  single_vecMul, star_one, one_mul] using h (Pi.single i 1) (Pi.single j 1)
state_before: case mpr.a.h
α : Type u_2
β : Type ?u.119376
m : Type ?u.119379
n : Type u_1
A✝ : Matrix n n α
inst✝³ : IsROrC α
inst✝² : IsROrC β
inst✝¹ : Fintype n
inst✝ : DecidableEq n
A : Matrix n n α
h : ∀ (x₁ x₂ : n → α), vecMul (star x₁) Aᴴ ⬝ᵥ x₂ = vecMul (star x₁) A ⬝ᵥ x₂
i j : n
⊢ Aᴴ i j = A i j
Theorem: Real.volume_pi_ball
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

tactic: simp only [MeasureTheory.volume_pi_ball a hr, volume_ball, Finset.prod_const]
state_before: ι : Type u_1
inst✝ : Fintype ι
a : ι → ℝ
r : ℝ
hr : 0 < r
⊢ ↑↑volume (Metric.ball a r) = ofReal ((2 * r) ^ Fintype.card ι)

tactic: exact (ENNReal.ofReal_pow (mul_nonneg zero_le_two hr.le) _).symm
state_before: ι : Type u_1
inst✝ : Fintype ι
a : ι → ℝ
r : ℝ
hr : 0 < r
⊢ ofReal (2 * r) ^ Finset.card Finset.univ = ofReal ((2 * r) ^ Fintype.card ι)
Theorem: List.filter_eq_filterTR
File: src/lean/Init/Data/List/Basic.lean

tactic: apply funext
state_before: α : Type u
β : Type v
γ : Type w
⊢ @filter = @filterTR

tactic: intro α
state_before: case h
α : Type u
β : Type v
γ : Type w
⊢ ∀ (x : Type u_1), filter = filterTR

tactic: apply funext
state_before: case h
α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
⊢ filter = filterTR

tactic: intro p
state_before: case h.h
α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
⊢ ∀ (x : α → Bool), filter x = filterTR x

tactic: apply funext
state_before: case h.h
α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
p : α → Bool
⊢ filter p = filterTR p

tactic: intro as
state_before: case h.h.h
α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
p : α → Bool
⊢ ∀ (x : List α), filter p x = filterTR p x

tactic: simp [filterTR, filterTR_loop_eq]
state_before: case h.h.h
α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
p : α → Bool
as : List α
⊢ filter p as = filterTR p as
Theorem: MvPolynomial.not_mem_support_iff
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: simp
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m✝ : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p✝ q p : MvPolynomial σ R
m : σ →₀ ℕ
⊢ ¬m ∈ support p ↔ coeff m p = 0
Theorem: Submodule.comap_subtype_eq_top
File: Mathlib/LinearAlgebra/Basic.lean

tactic: rw [map_subtype_top]
state_before: R : Type u_1
R₁ : Type ?u.1541683
R₂ : Type ?u.1541686
R₃ : Type ?u.1541689
R₄ : Type ?u.1541692
S : Type ?u.1541695
K : Type ?u.1541698
K₂ : Type ?u.1541701
M : Type u_2
M' : Type ?u.1541707
M₁ : Type ?u.1541710
M₂ : Type ?u.1541713
M₃ : Type ?u.1541716
M₄ : Type ?u.1541719
N : Type ?u.1541722
N₂ : Type ?u.1541725
ι : Type ?u.1541728
V : Type ?u.1541731
V₂ : Type ?u.1541734
inst✝⁵ : Semiring R
inst✝⁴ : Semiring R₂
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R₂ M₂
p✝ p'✝ : Submodule R M
q : Submodule R₂ M₂
τ₁₂ : R →+* R₂
F : Type ?u.1541908
sc : SemilinearMapClass F τ₁₂ M M₂
p p' : Submodule R M
⊢ map (Submodule.subtype p) ⊤ ≤ p' ↔ p ≤ p'
Theorem: Behrend.exp_four_lt
File: Mathlib/Combinatorics/Additive/Behrend.lean

tactic: rw [show (64 : ℝ) = 2 ^ ((6 : ℕ) : ℝ) by rw [rpow_nat_cast]; norm_num1,
  ← lt_log_iff_exp_lt (rpow_pos_of_pos zero_lt_two _), log_rpow zero_lt_two, ← div_lt_iff']
state_before: α : Type ?u.837007
β : Type ?u.837010
n d k N : ℕ
x : Fin n → ℕ
⊢ exp 4 < 64

tactic: exact log_two_gt_d9.trans_le' (by norm_num1)
state_before: α : Type ?u.837007
β : Type ?u.837010
n d k N : ℕ
x : Fin n → ℕ
⊢ 4 / ↑6 < log 2

α : Type ?u.837007
β : Type ?u.837010
n d k N : ℕ
x : Fin n → ℕ
⊢ 0 < ↑6

tactic: norm_num
state_before: α : Type ?u.837007
β : Type ?u.837010
n d k N : ℕ
x : Fin n → ℕ
⊢ 0 < ↑6

tactic: rw [rpow_nat_cast]
state_before: α : Type ?u.837007
β : Type ?u.837010
n d k N : ℕ
x : Fin n → ℕ
⊢ 64 = 2 ^ ↑6

tactic: norm_num1
state_before: α : Type ?u.837007
β : Type ?u.837010
n d k N : ℕ
x : Fin n → ℕ
⊢ 64 = 2 ^ 6

tactic: norm_num1
state_before: α : Type ?u.837007
β : Type ?u.837010
n d k N : ℕ
x : Fin n → ℕ
⊢ 4 / ↑6 ≤ 0.6931471803
Theorem: CategoryTheory.GlueData.types_ι_jointly_surjective
File: Mathlib/CategoryTheory/GlueData.lean

tactic: delta CategoryTheory.GlueData.ι
state_before: C : Type u₁
inst✝¹ : Category C
C' : Type u₂
inst✝ : Category C'
D✝ : GlueData C
D : GlueData (Type u_1)
x : glued D
⊢ ∃ i y, ι D i y = x

tactic: simp_rw [← Multicoequalizer.ι_sigmaπ D.diagram]
state_before: C : Type u₁
inst✝¹ : Category C
C' : Type u₂
inst✝ : Category C'
D✝ : GlueData C
D : GlueData (Type u_1)
x : glued D
⊢ ∃ i y, Multicoequalizer.π (diagram D) i y = x

tactic: rcases D.types_π_surjective x with ⟨x', rfl⟩
state_before: C : Type u₁
inst✝¹ : Category C
C' : Type u₂
inst✝ : Category C'
D✝ : GlueData C
D : GlueData (Type u_1)
x : glued D
⊢ ∃ i y, (Sigma.ι (diagram D).right i ≫ Multicoequalizer.sigmaπ (diagram D)) y = x

tactic: rw [← show (colimit.isoColimitCocone (Types.coproductColimitCocone _)).inv _ = x' from
    ConcreteCategory.congr_hom
      (colimit.isoColimitCocone (Types.coproductColimitCocone _)).hom_inv_id x']
state_before: case intro
C : Type u₁
inst✝¹ : Category C
C' : Type u₂
inst✝ : Category C'
D✝ : GlueData C
D : GlueData (Type u_1)
x' : sigmaOpens D
⊢ ∃ i y, (Sigma.ι (diagram D).right i ≫ Multicoequalizer.sigmaπ (diagram D)) y = π D x'

tactic: rcases(colimit.isoColimitCocone (Types.coproductColimitCocone _)).hom x' with ⟨i, y⟩
state_before: case intro
C : Type u₁
inst✝¹ : Category C
C' : Type u₂
inst✝ : Category C'
D✝ : GlueData C
D : GlueData (Type u_1)
x' : sigmaOpens D
⊢ ∃ i y,
    (Sigma.ι (diagram D).right i ≫ Multicoequalizer.sigmaπ (diagram D)) y =
      π D
        ((colimit.isoColimitCocone (Types.coproductColimitCocone D.U)).inv
          ((colimit.isoColimitCocone (Types.coproductColimitCocone D.U)).hom x'))

tactic: exact ⟨i, y, by
  simp [← Multicoequalizer.ι_sigmaπ, -Multicoequalizer.ι_sigmaπ]
  rfl ⟩
state_before: case intro.mk
C : Type u₁
inst✝¹ : Category C
C' : Type u₂
inst✝ : Category C'
D✝ : GlueData C
D : GlueData (Type u_1)
x' : sigmaOpens D
i : D.J
y : U D i
⊢ ∃ i_1 y_1,
    (Sigma.ι (diagram D).right i_1 ≫ Multicoequalizer.sigmaπ (diagram D)) y_1 =
      π D ((colimit.isoColimitCocone (Types.coproductColimitCocone D.U)).inv { fst := i, snd := y })

tactic: simp [← Multicoequalizer.ι_sigmaπ, -Multicoequalizer.ι_sigmaπ]
state_before: C : Type u₁
inst✝¹ : Category C
C' : Type u₂
inst✝ : Category C'
D✝ : GlueData C
D : GlueData (Type u_1)
x' : sigmaOpens D
i : D.J
y : U D i
⊢ (Sigma.ι (diagram D).right i ≫ Multicoequalizer.sigmaπ (diagram D)) y =
    π D ((colimit.isoColimitCocone (Types.coproductColimitCocone D.U)).inv { fst := i, snd := y })

tactic: rfl
state_before: C : Type u₁
inst✝¹ : Category C
C' : Type u₂
inst✝ : Category C'
D✝ : GlueData C
D : GlueData (Type u_1)
x' : sigmaOpens D
i : D.J
y : U D i
⊢ Multicoequalizer.sigmaπ (diagram D) (Sigma.ι D.U i y) =
    π D ((colimit.isoColimitCocone (Types.coproductColimitCocone D.U)).inv { fst := i, snd := y })
Theorem: Polynomial.degree_X_pow_add_C
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: have : degree (C a) < degree ((X : R[X]) ^ n) :=
  degree_C_le.trans_lt <| by rwa [degree_X_pow, Nat.cast_withBot, WithBot.coe_pos]
state_before: R : Type u
S : Type v
a✝ b c d : R
n✝ m : ℕ
inst✝¹ : Nontrivial R
inst✝ : Semiring R
n : ℕ
hn : 0 < n
a : R
⊢ degree (X ^ n + ↑C a) = ↑n

tactic: rw [degree_add_eq_left_of_degree_lt this, degree_X_pow]
state_before: R : Type u
S : Type v
a✝ b c d : R
n✝ m : ℕ
inst✝¹ : Nontrivial R
inst✝ : Semiring R
n : ℕ
hn : 0 < n
a : R
this : degree (↑C a) < degree (X ^ n)
⊢ degree (X ^ n + ↑C a) = ↑n

tactic: rwa [degree_X_pow, Nat.cast_withBot, WithBot.coe_pos]
state_before: R : Type u
S : Type v
a✝ b c d : R
n✝ m : ℕ
inst✝¹ : Nontrivial R
inst✝ : Semiring R
n : ℕ
hn : 0 < n
a : R
⊢ 0 < degree (X ^ n)
Theorem: rank_fun_eq_lift_mul
File: Mathlib/LinearAlgebra/Dimension.lean

tactic: rw [rank_pi, Cardinal.sum_const, Cardinal.mk_fintype, Cardinal.lift_natCast]
state_before: K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.533809
inst✝¹⁴ : Ring K
inst✝¹³ : StrongRankCondition K
inst✝¹² : AddCommGroup V
inst✝¹¹ : Module K V
inst✝¹⁰ : Module.Free K V
inst✝⁹ : AddCommGroup V'
inst✝⁸ : Module K V'
inst✝⁷ : Module.Free K V'
inst✝⁶ : AddCommGroup V₁
inst✝⁵ : Module K V₁
inst✝⁴ : Module.Free K V₁
inst✝³ : (i : η) → AddCommGroup (φ i)
inst✝² : (i : η) → Module K (φ i)
inst✝¹ : ∀ (i : η), Module.Free K (φ i)
inst✝ : Fintype η
⊢ Module.rank K (η → V) = ↑(Fintype.card η) * lift (Module.rank K V)
Theorem: Function.Embedding.toEquivRange_eq_ofInjective
File: Mathlib/Logic/Equiv/Fintype.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : DecidableEq β
e : Equiv.Perm α
f : α ↪ β
⊢ toEquivRange f = Equiv.ofInjective ↑f (_ : Injective ↑f)

tactic: simp
state_before: case H.a
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : DecidableEq β
e : Equiv.Perm α
f : α ↪ β
x✝ : α
⊢ ↑(↑(toEquivRange f) x✝) = ↑(↑(Equiv.ofInjective ↑f (_ : Injective ↑f)) x✝)
Theorem: eventually_nhds_norm_smul_sub_lt
File: Mathlib/Analysis/NormedSpace/Basic.lean

tactic: simp
state_before: α : Type u_2
β : Type ?u.15386
γ : Type ?u.15389
ι : Type ?u.15392
inst✝⁵ : NormedField α
inst✝⁴ : SeminormedAddCommGroup β
E : Type u_1
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace α E
F : Type ?u.15423
inst✝¹ : SeminormedAddCommGroup F
inst✝ : NormedSpace α F
c : α
x : E
ε : ℝ
h : 0 < ε
⊢ ‖c • (id x - x)‖ = 0
Theorem: Int.not_even_bit1
File: Mathlib/Data/Int/Parity.lean

tactic: simp [bit1, parity_simps]
state_before: m n✝ n : ℤ
⊢ ¬Even (bit1 n)
Theorem: Cardinal.mk_finsupp_lift_of_infinite
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: apply le_antisymm
state_before: α : Type u
β : Type v
inst✝² : Infinite α
inst✝¹ : Zero β
inst✝ : Nontrivial β
⊢ (#α →₀ β) = max (lift (#α)) (lift (#β))

tactic: calc
  (#α →₀ β) ≤ (#Finset (α × β)) := mk_le_of_injective (Finsupp.graph_injective α β)
  _ = (#α × β) := mk_finset_of_infinite _
  _ = max (lift.{v} (#α)) (lift.{u} (#β)) :=
    by rw [mk_prod, mul_eq_max_of_aleph0_le_left] <;> simp
state_before: case a
α : Type u
β : Type v
inst✝² : Infinite α
inst✝¹ : Zero β
inst✝ : Nontrivial β
⊢ (#α →₀ β) ≤ max (lift (#α)) (lift (#β))

tactic: rw [mk_prod, mul_eq_max_of_aleph0_le_left] <;> simp
state_before: α : Type u
β : Type v
inst✝² : Infinite α
inst✝¹ : Zero β
inst✝ : Nontrivial β
⊢ (#α × β) = max (lift (#α)) (lift (#β))

tactic: apply max_le <;> rw [← lift_id (#α →₀ β), ← lift_umax]
state_before: case a
α : Type u
β : Type v
inst✝² : Infinite α
inst✝¹ : Zero β
inst✝ : Nontrivial β
⊢ max (lift (#α)) (lift (#β)) ≤ (#α →₀ β)

tactic: cases' exists_ne (0 : β) with b hb
state_before: case a.h₁
α : Type u
β : Type v
inst✝² : Infinite α
inst✝¹ : Zero β
inst✝ : Nontrivial β
⊢ lift (#α) ≤ lift (#α →₀ β)

tactic: exact lift_mk_le.{u, max u v, v}.2 ⟨⟨_, Finsupp.single_left_injective hb⟩⟩
state_before: case a.h₁.intro
α : Type u
β : Type v
inst✝² : Infinite α
inst✝¹ : Zero β
inst✝ : Nontrivial β
b : β
hb : b ≠ 0
⊢ lift (#α) ≤ lift (#α →₀ β)

tactic: inhabit α
state_before: case a.h₂
α : Type u
β : Type v
inst✝² : Infinite α
inst✝¹ : Zero β
inst✝ : Nontrivial β
⊢ lift (#β) ≤ lift (#α →₀ β)

tactic: exact lift_mk_le.{v, max u v, u}.2 ⟨⟨_, Finsupp.single_injective default⟩⟩
state_before: case a.h₂
α : Type u
β : Type v
inst✝² : Infinite α
inst✝¹ : Zero β
inst✝ : Nontrivial β
inhabited_h : Inhabited α
⊢ lift (#β) ≤ lift (#α →₀ β)
Theorem: Finset.disjoint_iff_ne
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [disjoint_left, imp_not_comm, forall_eq']
state_before: α : Type u_1
β : Type ?u.45481
γ : Type ?u.45484
f : α → β
s t u : Finset α
a b : α
⊢ _root_.Disjoint s t ↔ ∀ (a : α), a ∈ s → ∀ (b : α), b ∈ t → a ≠ b
Theorem: Cardinal.iSup_lt_of_isRegular
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rwa [hc.cof_eq]
state_before: α : Type ?u.160773
r : α → α → Prop
ι : Type u_1
f : ι → Cardinal
c : Cardinal
hc : IsRegular c
hι : (#ι) < c
⊢ (#ι) < Ordinal.cof (ord c)
Theorem: Matrix.IsDiag.map
File: Mathlib/LinearAlgebra/Matrix/IsDiag.lean

tactic: intro i j h
state_before: α : Type u_1
β : Type u_2
R : Type ?u.2825
n : Type u_3
m : Type ?u.2831
inst✝¹ : Zero α
inst✝ : Zero β
A : Matrix n n α
ha : IsDiag A
f : α → β
hf : f 0 = 0
⊢ IsDiag (Matrix.map A f)

tactic: simp [ha h, hf]
state_before: α : Type u_1
β : Type u_2
R : Type ?u.2825
n : Type u_3
m : Type ?u.2831
inst✝¹ : Zero α
inst✝ : Zero β
A : Matrix n n α
ha : IsDiag A
f : α → β
hf : f 0 = 0
i j : n
h : i ≠ j
⊢ Matrix.map A f i j = 0
Theorem: nsmul_eq_self
File: Mathlib/Algebra/Order/Kleene.lean

tactic: rw [succ_nsmul, nsmul_eq_self n.succ_ne_zero, add_idem]
state_before: α : Type u_1
β : Type ?u.18224
ι : Type ?u.18227
π : ι → Type ?u.18232
inst✝ : IdemSemiring α
a✝ b c : α
n : ℕ
x✝ : n + 2 ≠ 0
a : α
⊢ (n + 2) • a = a
Theorem: Submodule.fg_iff_add_subgroup_fg
File: Mathlib/RingTheory/Finiteness.lean

tactic: simpa [← span_int_eq_addSubgroup_closure] using hS
state_before: R : Type ?u.2420
M : Type ?u.2423
inst✝³ : Semiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
G : Type u_1
inst✝ : AddCommGroup G
P : Submodule ℤ G
x✝ : FG P
S : Finset G
hS : span ℤ ↑S = P
⊢ AddSubgroup.closure ↑S = toAddSubgroup P

tactic: simpa [← span_int_eq_addSubgroup_closure] using hS
state_before: R : Type ?u.2420
M : Type ?u.2423
inst✝³ : Semiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
G : Type u_1
inst✝ : AddCommGroup G
P : Submodule ℤ G
x✝ : AddSubgroup.FG (toAddSubgroup P)
S : Finset G
hS : AddSubgroup.closure ↑S = toAddSubgroup P
⊢ span ℤ ↑S = P
Theorem: Set.monotoneOn_iff_monotone
File: Mathlib/Data/Set/Basic.lean

tactic: simp [Monotone, MonotoneOn]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
⊢ MonotoneOn f s ↔ Monotone fun a => f ↑a
Theorem: SMul.comp.isScalarTower
File: Mathlib/GroupTheory/GroupAction/Defs.lean

tactic: haveI := comp α g
state_before: M : Type ?u.9269
N : Type ?u.9272
G : Type ?u.9275
A : Type ?u.9278
B : Type ?u.9281
α : Type ?u.9284
β : Type ?u.9287
γ : Type ?u.9290
δ : Type ?u.9293
inst✝³ : SMul M α
inst✝² : SMul M β
inst✝¹ : SMul α β
inst✝ : IsScalarTower M α β
g : N → M
⊢ Sort ?u.9343

tactic: haveI := comp β g
state_before: M : Type ?u.9269
N : Type ?u.9272
G : Type ?u.9275
A : Type ?u.9278
B : Type ?u.9281
α : Type ?u.9284
β : Type ?u.9287
γ : Type ?u.9290
δ : Type ?u.9293
inst✝³ : SMul M α
inst✝² : SMul M β
inst✝¹ : SMul α β
inst✝ : IsScalarTower M α β
g : N → M
this : SMul N α
⊢ Sort ?u.9343

tactic: exact IsScalarTower N α β
state_before: M : Type ?u.9269
N : Type ?u.9272
G : Type ?u.9275
A : Type ?u.9278
B : Type ?u.9281
α : Type ?u.9284
β : Type ?u.9287
γ : Type ?u.9290
δ : Type ?u.9293
inst✝³ : SMul M α
inst✝² : SMul M β
inst✝¹ : SMul α β
inst✝ : IsScalarTower M α β
g : N → M
this✝ : SMul N α
this : SMul N β
⊢ Sort ?u.9343
Theorem: CategoryTheory.Subobject.pullback_map_self
File: Mathlib/CategoryTheory/Subobject/Basic.lean

tactic: revert g
state_before: C : Type u₁
inst✝³ : Category C
X Y Z : C
D : Type u₂
inst✝² : Category D
inst✝¹ : HasPullbacks C
f : X ⟶ Y
inst✝ : Mono f
g : Subobject X
⊢ (pullback f).obj ((map f).obj g) = g

tactic: exact Quotient.ind (fun g' => Quotient.sound ⟨(MonoOver.pullbackMapSelf f).app _⟩)
state_before: C : Type u₁
inst✝³ : Category C
X Y Z : C
D : Type u₂
inst✝² : Category D
inst✝¹ : HasPullbacks C
f : X ⟶ Y
inst✝ : Mono f
⊢ ∀ (g : Subobject X), (pullback f).obj ((map f).obj g) = g
Theorem: Finsupp.toFreeAbelianGroup_comp_toFinsupp
File: Mathlib/GroupTheory/FreeAbelianGroupFinsupp.lean

tactic: ext
state_before: X : Type u_1
⊢ AddMonoidHom.comp toFreeAbelianGroup toFinsupp = AddMonoidHom.id (FreeAbelianGroup X)

tactic: rw [toFreeAbelianGroup, toFinsupp, AddMonoidHom.comp_apply, lift.of,
  liftAddHom_apply_single, AddMonoidHom.flip_apply, smulAddHom_apply, one_smul,
  AddMonoidHom.id_apply]
state_before: case H
X : Type u_1
x✝ : X
⊢ ↑(AddMonoidHom.comp toFreeAbelianGroup toFinsupp) (of x✝) = ↑(AddMonoidHom.id (FreeAbelianGroup X)) (of x✝)
Theorem: Turing.Tape.map_move
File: Mathlib/Computability/TuringMachine.lean

tactic: cases T
state_before: Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
f : PointedMap Γ Γ'
T : Tape Γ
d : Dir
⊢ map f (move d T) = move d (map f T)

tactic: cases d <;> simp only [Tape.move, Tape.map, ListBlank.head_map, eq_self_iff_true,
  ListBlank.map_cons, and_self_iff, ListBlank.tail_map]
state_before: case mk
Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
f : PointedMap Γ Γ'
d : Dir
head✝ : Γ
left✝ right✝ : ListBlank Γ
⊢ map f (move d { head := head✝, left := left✝, right := right✝ }) =
    move d (map f { head := head✝, left := left✝, right := right✝ })
Theorem: abs_sub_lt_iff
File: Mathlib/Algebra/Order/Group/Abs.lean

tactic: rw [@abs_lt α, neg_lt_sub_iff_lt_add', sub_lt_iff_lt_add', and_comm, sub_lt_iff_lt_add']
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
⊢ abs (a - b) < c ↔ a - b < c ∧ b - a < c
Theorem: ZMod.charpoly_pow_card
File: Mathlib/LinearAlgebra/Matrix/Charpoly/FiniteField.lean

tactic: have h := FiniteField.Matrix.charpoly_pow_card M
state_before: n : Type u_1
inst✝² : DecidableEq n
inst✝¹ : Fintype n
p : ℕ
inst✝ : Fact (Nat.Prime p)
M : Matrix n n (ZMod p)
⊢ charpoly (M ^ p) = charpoly M

tactic: rwa [ZMod.card] at h
state_before: n : Type u_1
inst✝² : DecidableEq n
inst✝¹ : Fintype n
p : ℕ
inst✝ : Fact (Nat.Prime p)
M : Matrix n n (ZMod p)
h : charpoly (M ^ Fintype.card (ZMod p)) = charpoly M
⊢ charpoly (M ^ p) = charpoly M
Theorem: UpperSet.prod_le_prod_iff
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.175540
ι : Sort ?u.175543
κ : ι → Sort ?u.175548
inst✝¹ : Preorder α
inst✝ : Preorder β
s s₁ s₂ : UpperSet α
t t₁ t₂ : UpperSet β
x : α × β
⊢ ↑s₂ ⊆ ↑s₁ ∧ ↑t₂ ⊆ ↑t₁ ∨ ↑s₂ = ∅ ∨ ↑t₂ = ∅ ↔ s₁ ≤ s₂ ∧ t₁ ≤ t₂ ∨ s₂ = ⊤ ∨ t₂ = ⊤