tasksource/leandojo huggingface dataset:
Theorem: Asymptotics.SuperpolynomialDecay.inv_param_mul
File: Mathlib/Analysis/Asymptotics/SuperpolynomialDecay.lean

tactic: simpa using hf.param_zpow_mul hk (-1)
state_before: α : Type u_1
β : Type u_2
l : Filter α
k f g g' : α → β
inst✝² : TopologicalSpace β
inst✝¹ : LinearOrderedField β
inst✝ : OrderTopology β
hk : Tendsto k l atTop
hf : SuperpolynomialDecay l k f
⊢ SuperpolynomialDecay l k (k⁻¹ * f)
Theorem: Function.isPeriodicPt_minimalPeriod
File: Mathlib/Dynamics/PeriodicPts.lean

tactic: delta minimalPeriod
state_before: α : Type u_1
β : Type ?u.19001
f✝ fa : α → α
fb : β → β
x✝ y : α
m n : ℕ
f : α → α
x : α
⊢ IsPeriodicPt f (minimalPeriod f x) x

tactic: split_ifs with hx
state_before: α : Type u_1
β : Type ?u.19001
f✝ fa : α → α
fb : β → β
x✝ y : α
m n : ℕ
f : α → α
x : α
⊢ IsPeriodicPt f (if h : x ∈ periodicPts f then Nat.find h else 0) x

tactic: exact (Nat.find_spec hx).2
state_before: case inl
α : Type u_1
β : Type ?u.19001
f✝ fa : α → α
fb : β → β
x✝ y : α
m n : ℕ
f : α → α
x : α
hx : x ∈ periodicPts f
⊢ IsPeriodicPt f (Nat.find hx) x

tactic: exact isPeriodicPt_zero f x
state_before: case inr
α : Type u_1
β : Type ?u.19001
f✝ fa : α → α
fb : β → β
x✝ y : α
m n : ℕ
f : α → α
x : α
hx : ¬x ∈ periodicPts f
⊢ IsPeriodicPt f 0 x
Theorem: List.length_sublists'
File: Mathlib/Data/List/Sublists.lean

tactic: simp_arith only [sublists'_cons, length_append, length_sublists' l,
  length_map, length, Nat.pow_succ', mul_succ, mul_zero, zero_add]
state_before: α : Type u
β : Type v
γ : Type w
a : α
l : List α
⊢ length (sublists' (a :: l)) = 2 ^ length (a :: l)
Theorem: idealFactorsFunOfQuotHom_id
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

tactic: simp only [idealFactorsFunOfQuotHom, map_id, OrderHom.coe_fun_mk, OrderHom.id_coe, id.def,
  comap_map_of_surjective (Ideal.Quotient.mk J) Quotient.mk_surjective, ←
  RingHom.ker_eq_comap_bot (Ideal.Quotient.mk J), mk_ker,
  sup_eq_left.mpr (dvd_iff_le.mp X.prop), Subtype.coe_eta]
state_before: R : Type ?u.977234
A : Type u_1
K : Type ?u.977240
inst✝⁴ : CommRing R
inst✝³ : CommRing A
inst✝² : Field K
inst✝¹ : IsDomain A
inst✝ : IsDedekindDomain A
I : Ideal R
J : Ideal A
X : ↑{p | p ∣ J}
⊢ ↑(idealFactorsFunOfQuotHom (_ : Function.Surjective ↑(RingHom.id (A ⧸ J)))) X = ↑OrderHom.id X
Theorem: IsUnit.div_eq_div_iff
File: Mathlib/Algebra/Hom/Units.lean

tactic: rw [← (hb.mul hd).mul_left_inj, ← mul_assoc, hb.div_mul_cancel, ← mul_assoc, mul_right_comm,
  hd.div_mul_cancel]
state_before: F : Type ?u.65500
G : Type ?u.65503
α : Type u_1
M : Type ?u.65509
N : Type ?u.65512
inst✝ : DivisionCommMonoid α
a b c d : α
hb : IsUnit b
hd : IsUnit d
⊢ a / b = c / d ↔ a * d = c * b
Theorem: MeasureTheory.MeasurePreserving.comp_left_iff
File: Mathlib/Dynamics/Ergodic/MeasurePreserving.lean

tactic: refine' ⟨fun hg => _, fun hg => h.comp hg⟩
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.54964
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
μa : Measure α
μb : Measure β
μc : Measure γ
μd : Measure δ
g : α → β
e : β ≃ᵐ γ
h : MeasurePreserving ↑e
⊢ MeasurePreserving (↑e ∘ g) ↔ MeasurePreserving g

tactic: convert (MeasurePreserving.symm e h).comp hg
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.54964
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
μa : Measure α
μb : Measure β
μc : Measure γ
μd : Measure δ
g : α → β
e : β ≃ᵐ γ
h : MeasurePreserving ↑e
hg : MeasurePreserving (↑e ∘ g)
⊢ MeasurePreserving g

tactic: simp [← Function.comp.assoc e.symm e g]
state_before: case h.e'_5
α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.54964
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
μa : Measure α
μb : Measure β
μc : Measure γ
μd : Measure δ
g : α → β
e : β ≃ᵐ γ
h : MeasurePreserving ↑e
hg : MeasurePreserving (↑e ∘ g)
⊢ g = ↑(MeasurableEquiv.symm e) ∘ ↑e ∘ g
Theorem: SimpleGraph.Walk.map_eq_nil_iff
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: cases p <;> simp
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' : V
p✝ : Walk G u v
p : Walk G u u
⊢ Walk.map f p = nil ↔ p = nil
Theorem: CategoryTheory.Subobject.mk_factors_self
File: Mathlib/CategoryTheory/Subobject/FactorThru.lean

tactic: simp
state_before: C : Type u₁
inst✝² : Category C
X Y Z : C
D : Type u₂
inst✝¹ : Category D
f : X ⟶ Y
inst✝ : Mono f
⊢ 𝟙 X ≫ MonoOver.arrow (MonoOver.mk' f) = f
Theorem: Finset.prod_cancels_of_partition_cancels
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: rw [prod_partition R, ← Finset.prod_eq_one]
state_before: ι : Type ?u.788537
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : CommMonoid β
R : Setoid α
inst✝ : DecidableRel Setoid.r
h : ∀ (x : α), x ∈ s → ∏ a in filter (fun y => y ≈ x) s, f a = 1
⊢ ∏ x in s, f x = 1

tactic: intro xbar xbar_in_s
state_before: ι : Type ?u.788537
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : CommMonoid β
R : Setoid α
inst✝ : DecidableRel Setoid.r
h : ∀ (x : α), x ∈ s → ∏ a in filter (fun y => y ≈ x) s, f a = 1
⊢ ∀ (x : Quotient R), x ∈ image Quotient.mk'' s → ∏ y in filter (fun x_1 => Quotient.mk R x_1 = x) s, f y = 1

tactic: obtain ⟨x, x_in_s, rfl⟩ := mem_image.mp xbar_in_s
state_before: ι : Type ?u.788537
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : CommMonoid β
R : Setoid α
inst✝ : DecidableRel Setoid.r
h : ∀ (x : α), x ∈ s → ∏ a in filter (fun y => y ≈ x) s, f a = 1
xbar : Quotient R
xbar_in_s : xbar ∈ image Quotient.mk'' s
⊢ ∏ y in filter (fun x => Quotient.mk R x = xbar) s, f y = 1

tactic: simp only [← Quotient.eq] at h
state_before: case intro.intro
ι : Type ?u.788537
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : CommMonoid β
R : Setoid α
inst✝ : DecidableRel Setoid.r
h : ∀ (x : α), x ∈ s → ∏ a in filter (fun y => y ≈ x) s, f a = 1
x : α
x_in_s : x ∈ s
xbar_in_s : Quotient.mk'' x ∈ image Quotient.mk'' s
⊢ ∏ y in filter (fun x_1 => Quotient.mk R x_1 = Quotient.mk'' x) s, f y = 1

tactic: exact h x x_in_s
state_before: case intro.intro
ι : Type ?u.788537
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : CommMonoid β
R : Setoid α
inst✝ : DecidableRel Setoid.r
x : α
x_in_s : x ∈ s
xbar_in_s : Quotient.mk'' x ∈ image Quotient.mk'' s
h : ∀ (x : α), x ∈ s → ∏ x in filter (fun y => Quotient.mk R y = Quotient.mk R x) s, f x = 1
⊢ ∏ y in filter (fun x_1 => Quotient.mk R x_1 = Quotient.mk'' x) s, f y = 1
Theorem: Order.pred_eq_pred_iff
File: Mathlib/Order/SuccPred/Basic.lean

tactic: simp_rw [eq_iff_le_not_lt, pred_le_pred_iff, pred_lt_pred_iff]
state_before: α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : PredOrder α
a b : α
inst✝ : NoMinOrder α
⊢ pred a = pred b ↔ a = b
Theorem: hasStrictFDerivAt_norm_sq
File: Mathlib/Analysis/InnerProductSpace/Calculus.lean

tactic: simp only [sq, ← @inner_self_eq_norm_mul_norm ℝ]
state_before: 𝕜 : Type ?u.299226
E : Type ?u.299229
F : Type u_1
inst✝⁷ : IsROrC 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
inst✝² : NormedSpace ℝ E
G : Type ?u.299361
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f g : G → E
f' g' : G →L[ℝ] E
s : Set G
x✝ : G
n : ℕ∞
x : F
⊢ HasStrictFDerivAt (fun x => ‖x‖ ^ 2) (2 • ↑(innerSL ℝ) x) x

tactic: convert (hasStrictFDerivAt_id x).inner ℝ (hasStrictFDerivAt_id x)
state_before: 𝕜 : Type ?u.299226
E : Type ?u.299229
F : Type u_1
inst✝⁷ : IsROrC 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
inst✝² : NormedSpace ℝ E
G : Type ?u.299361
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f g : G → E
f' g' : G →L[ℝ] E
s : Set G
x✝ : G
n : ℕ∞
x : F
⊢ HasStrictFDerivAt (fun x => ↑re (inner x x)) (2 • ↑(innerSL ℝ) x) x

tactic: ext y
state_before: case h.e'_10.h.h
𝕜 : Type ?u.299226
E : Type ?u.299229
F : Type u_1
inst✝⁷ : IsROrC 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
inst✝² : NormedSpace ℝ E
G : Type ?u.299361
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f g : G → E
f' g' : G →L[ℝ] E
s : Set G
x✝ : G
n : ℕ∞
x : F
e_7✝ : normedAddCommGroup = NonUnitalNormedRing.toNormedAddCommGroup
he✝ : InnerProductSpace.toNormedSpace = NormedAlgebra.toNormedSpace'
⊢ 2 • ↑(innerSL ℝ) x =
    ContinuousLinearMap.comp (fderivInnerClm ℝ (id x, id x))
      (ContinuousLinearMap.prod (ContinuousLinearMap.id ℝ F) (ContinuousLinearMap.id ℝ F))

tactic: simp [two_smul, real_inner_comm]
state_before: case h.e'_10.h.h.h
𝕜 : Type ?u.299226
E : Type ?u.299229
F : Type u_1
inst✝⁷ : IsROrC 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
inst✝² : NormedSpace ℝ E
G : Type ?u.299361
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f g : G → E
f' g' : G →L[ℝ] E
s : Set G
x✝ : G
n : ℕ∞
x : F
e_7✝ : normedAddCommGroup = NonUnitalNormedRing.toNormedAddCommGroup
he✝ : InnerProductSpace.toNormedSpace = NormedAlgebra.toNormedSpace'
y : F
⊢ ↑(2 • ↑(innerSL ℝ) x) y =
    ↑(ContinuousLinearMap.comp (fderivInnerClm ℝ (id x, id x))
          (ContinuousLinearMap.prod (ContinuousLinearMap.id ℝ F) (ContinuousLinearMap.id ℝ F)))
      y
Theorem: joined_genLoopZeroEquiv_iff
File: Mathlib/Topology/Homotopy/HomotopyGroup.lean

tactic: rw [← homotopic_genLoopZeroEquiv_symm_iff, Equiv.symm_apply_apply, Equiv.symm_apply_apply]
state_before: X : Type u
inst✝ : TopologicalSpace X
n : ℕ
x : X
f g : GenLoop 0 x
⊢ Joined (↑genLoopZeroEquiv f) (↑genLoopZeroEquiv g) ↔ GenLoop.Homotopic f g
Theorem: Filter.IsBoundedUnder.isLittleO_sub_self_inv
File: Mathlib/Analysis/Asymptotics/SpecificAsymptotics.lean

tactic: refine' (h.isBigO_const (one_ne_zero' ℝ)).trans_isLittleO (isLittleO_const_left.2 <| Or.inr _)
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝¹ : NormedField 𝕜
inst✝ : Norm E
a : 𝕜
f : 𝕜 → E
h : IsBoundedUnder (fun x x_1 => x ≤ x_1) (𝓝[{a}ᶜ] a) (norm ∘ f)
⊢ f =o[𝓝[{a}ᶜ] a] fun x => (x - a)⁻¹

tactic: exact (tendsto_norm_sub_self_punctured_nhds a).inv_tendsto_zero
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝¹ : NormedField 𝕜
inst✝ : Norm E
a : 𝕜
f : 𝕜 → E
h : IsBoundedUnder (fun x x_1 => x ≤ x_1) (𝓝[{a}ᶜ] a) (norm ∘ f)
⊢ Tendsto (fun x => ‖x - a‖⁻¹) (𝓝[{a}ᶜ] a) atTop
Theorem: Polynomial.leadingCoeff_mul
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: by_cases hp : p = 0
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p✝ q✝ p q : R[X]
⊢ leadingCoeff (p * q) = leadingCoeff p * leadingCoeff q

tactic: simp only [hp, zero_mul, leadingCoeff_zero]
state_before: case pos
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p✝ q✝ p q : R[X]
hp : p = 0
⊢ leadingCoeff (p * q) = leadingCoeff p * leadingCoeff q

tactic: by_cases hq : q = 0
state_before: case neg
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p✝ q✝ p q : R[X]
hp : ¬p = 0
⊢ leadingCoeff (p * q) = leadingCoeff p * leadingCoeff q

tactic: simp only [hq, mul_zero, leadingCoeff_zero]
state_before: case pos
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p✝ q✝ p q : R[X]
hp : ¬p = 0
hq : q = 0
⊢ leadingCoeff (p * q) = leadingCoeff p * leadingCoeff q

tactic: rw [leadingCoeff_mul']
state_before: case neg
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p✝ q✝ p q : R[X]
hp : ¬p = 0
hq : ¬q = 0
⊢ leadingCoeff (p * q) = leadingCoeff p * leadingCoeff q

tactic: exact mul_ne_zero (mt leadingCoeff_eq_zero.1 hp) (mt leadingCoeff_eq_zero.1 hq)
state_before: case neg
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p✝ q✝ p q : R[X]
hp : ¬p = 0
hq : ¬q = 0
⊢ leadingCoeff p * leadingCoeff q ≠ 0
Theorem: Option.map₂_map_left
File: Mathlib/Data/Option/NAry.lean

tactic: cases a <;> rfl
state_before: α : Type u_4
β : Type u_3
γ : Type u_2
f✝ : α → β → γ
a : Option α
b : Option β
c : Option γ
δ : Type u_1
f : γ → β → δ
g : α → γ
⊢ map₂ f (Option.map g a) b = map₂ (fun a b => f (g a) b) a b
Theorem: QuadraticForm.polar_comp
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

tactic: simp only [polar, Pi.smul_apply, Function.comp_apply, map_sub]
state_before: S : Type u_2
R : Type u_3
R₁ : Type ?u.15005
M : Type u_4
inst✝⁴ : Ring R
inst✝³ : CommRing R₁
inst✝² : AddCommGroup M
F : Type u_1
inst✝¹ : Ring S
inst✝ : AddMonoidHomClass F R S
f : M → R
g : F
x y : M
⊢ polar (↑g ∘ f) x y = ↑g (polar f x y)
Theorem: Nat.modEq_nine_digits_sum
File: Mathlib/Data/Nat/Digits.lean

tactic: norm_num
state_before: n✝ n : ℕ
⊢ 10 % 9 = 1
Theorem: Matrix.conjTranspose_add
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp
state_before: l : Type ?u.962514
m : Type u_1
n : Type u_2
o : Type ?u.962523
m' : o → Type ?u.962528
n' : o → Type ?u.962533
R : Type ?u.962536
S : Type ?u.962539
α : Type v
β : Type w
γ : Type ?u.962546
inst✝¹ : AddMonoid α
inst✝ : StarAddMonoid α
M N : Matrix m n α
⊢ ∀ (i : n) (j : m), (M + N)ᴴ i j = (Mᴴ + Nᴴ) i j
Theorem: Ideal.polynomialQuotientEquivQuotientPolynomial_symm_mk
File: Mathlib/RingTheory/Polynomial/Quotient.lean

tactic: rw [polynomialQuotientEquivQuotientPolynomial, RingEquiv.symm_mk, RingEquiv.coe_mk,
  Equiv.coe_fn_mk, Quotient.lift_mk, coe_eval₂RingHom, eval₂_eq_eval_map, ← Polynomial.map_map,
  ← eval₂_eq_eval_map, Polynomial.eval₂_C_X]
state_before: R : Type u_1
inst✝ : CommRing R
I : Ideal R
f : R[X]
⊢ ↑(RingEquiv.symm (polynomialQuotientEquivQuotientPolynomial I)) (↑(Quotient.mk (map C I)) f) =
    Polynomial.map (Quotient.mk I) f
Theorem: Commute.add_pow_prime_eq
File: Mathlib/Algebra/CharP/Basic.lean

tactic: simpa using h.add_pow_prime_pow_eq hp 1
state_before: R : Type u_1
inst✝ : Semiring R
p : ℕ
x y : R
hp : Nat.Prime p
h : Commute x y
⊢ (x + y) ^ p = x ^ p + y ^ p + ↑p * ∑ k in Ioo 0 p, x ^ k * y ^ (p - k) * ↑(Nat.choose p k / p)
Theorem: CauSeq.lt_of_lt_of_eq
File: Mathlib/Data/Real/CauSeq.lean

tactic: convert pos_add_limZero fg (neg_limZero gh) using 1
state_before: α : Type u_1
inst✝ : LinearOrderedField α
f g h : CauSeq α abs
fg : f < g
gh : g ≈ h
⊢ Pos (h - f)

tactic: simp
state_before: case h.e'_3
α : Type u_1
inst✝ : LinearOrderedField α
f g h : CauSeq α abs
fg : f < g
gh : g ≈ h
⊢ h - f = g - f + -(g - h)
Theorem: List.nth_le_tails
File: Mathlib/Data/List/Infix.lean

tactic: induction' l with x l IH generalizing n
state_before: α : Type u_1
β : Type ?u.49282
l✝ l₁ l₂ l₃ : List α
a b : α
m n✝ : ℕ
l : List α
n : ℕ
hn : n < length (tails l)
⊢ nthLe (tails l) n hn = drop n l

tactic: simp
state_before: case nil
α : Type u_1
β : Type ?u.49282
l✝ l₁ l₂ l₃ : List α
a b : α
m n✝¹ : ℕ
l : List α
n✝ : ℕ
hn✝ : n✝ < length (tails l)
n : ℕ
hn : n < length (tails [])
⊢ nthLe (tails []) n hn = drop n []

tactic: cases n
state_before: case cons
α : Type u_1
β : Type ?u.49282
l✝¹ l₁ l₂ l₃ : List α
a b : α
m n✝¹ : ℕ
l✝ : List α
n✝ : ℕ
hn✝ : n✝ < length (tails l✝)
x : α
l : List α
IH : ∀ (n : ℕ) (hn : n < length (tails l)), nthLe (tails l) n hn = drop n l
n : ℕ
hn : n < length (tails (x :: l))
⊢ nthLe (tails (x :: l)) n hn = drop n (x :: l)

tactic: simp[nthLe_cons]
state_before: case cons.zero
α : Type u_1
β : Type ?u.49282
l✝¹ l₁ l₂ l₃ : List α
a b : α
m n✝ : ℕ
l✝ : List α
n : ℕ
hn✝ : n < length (tails l✝)
x : α
l : List α
IH : ∀ (n : ℕ) (hn : n < length (tails l)), nthLe (tails l) n hn = drop n l
hn : zero < length (tails (x :: l))
⊢ nthLe (tails (x :: l)) zero hn = drop zero (x :: l)

tactic: simpa[nthLe_cons] using IH _ _
state_before: case cons.succ
α : Type u_1
β : Type ?u.49282
l✝¹ l₁ l₂ l₃ : List α
a b : α
m n✝¹ : ℕ
l✝ : List α
n : ℕ
hn✝ : n < length (tails l✝)
x : α
l : List α
IH : ∀ (n : ℕ) (hn : n < length (tails l)), nthLe (tails l) n hn = drop n l
n✝ : ℕ
hn : succ n✝ < length (tails (x :: l))
⊢ nthLe (tails (x :: l)) (succ n✝) hn = drop (succ n✝) (x :: l)
Theorem: Matrix.tail_transpose
File: Mathlib/Data/Matrix/Notation.lean

tactic: ext (i j)
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
A : Matrix m' (Fin (Nat.succ n)) α
⊢ vecTail (↑of.symm Aᵀ) = (vecTail ∘ A)ᵀ

tactic: rfl
state_before: case h.h
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
A : Matrix m' (Fin (Nat.succ n)) α
i : Fin n
j : m'
⊢ vecTail (↑of.symm Aᵀ) i j = (vecTail ∘ A)ᵀ i j
Theorem: BoxIntegral.Box.injective_coe
File: Mathlib/Analysis/BoxIntegral/Box/Basic.lean

tactic: rintro ⟨l₁, u₁, h₁⟩ ⟨l₂, u₂, h₂⟩ h
state_before: ι : Type u_1
I J : Box ι
x y : ι → ℝ
⊢ Injective toSet

tactic: simp only [Subset.antisymm_iff, coe_subset_coe, le_iff_bounds] at h
state_before: case mk.mk
ι : Type u_1
I J : Box ι
x y l₁ u₁ : ι → ℝ
h₁ : ∀ (i : ι), l₁ i < u₁ i
l₂ u₂ : ι → ℝ
h₂ : ∀ (i : ι), l₂ i < u₂ i
h : ↑{ lower := l₁, upper := u₁, lower_lt_upper := h₁ } = ↑{ lower := l₂, upper := u₂, lower_lt_upper := h₂ }
⊢ { lower := l₁, upper := u₁, lower_lt_upper := h₁ } = { lower := l₂, upper := u₂, lower_lt_upper := h₂ }

tactic: congr
state_before: case mk.mk
ι : Type u_1
I J : Box ι
x y l₁ u₁ : ι → ℝ
h₁ : ∀ (i : ι), l₁ i < u₁ i
l₂ u₂ : ι → ℝ
h₂ : ∀ (i : ι), l₂ i < u₂ i
h : (l₂ ≤ l₁ ∧ u₁ ≤ u₂) ∧ l₁ ≤ l₂ ∧ u₂ ≤ u₁
⊢ { lower := l₁, upper := u₁, lower_lt_upper := h₁ } = { lower := l₂, upper := u₂, lower_lt_upper := h₂ }

tactic: exacts [le_antisymm h.2.1 h.1.1, le_antisymm h.1.2 h.2.2]
state_before: case mk.mk.e_lower
ι : Type u_1
I J : Box ι
x y l₁ u₁ : ι → ℝ
h₁ : ∀ (i : ι), l₁ i < u₁ i
l₂ u₂ : ι → ℝ
h₂ : ∀ (i : ι), l₂ i < u₂ i
h : (l₂ ≤ l₁ ∧ u₁ ≤ u₂) ∧ l₁ ≤ l₂ ∧ u₂ ≤ u₁
⊢ l₁ = l₂

case mk.mk.e_upper
ι : Type u_1
I J : Box ι
x y l₁ u₁ : ι → ℝ
h₁ : ∀ (i : ι), l₁ i < u₁ i
l₂ u₂ : ι → ℝ
h₂ : ∀ (i : ι), l₂ i < u₂ i
h : (l₂ ≤ l₁ ∧ u₁ ≤ u₂) ∧ l₁ ≤ l₂ ∧ u₂ ≤ u₁
⊢ u₁ = u₂
Theorem: CharP.neg_one_pow_char_pow
File: Mathlib/Algebra/CharP/Basic.lean

tactic: rw [eq_neg_iff_add_eq_zero]
state_before: R : Type u_1
inst✝² : CommRing R
p n : ℕ
inst✝¹ : CharP R p
inst✝ : Fact (Nat.Prime p)
⊢ (-1) ^ p ^ n = -1

tactic: nth_rw 2 [← one_pow (p ^ n)]
state_before: R : Type u_1
inst✝² : CommRing R
p n : ℕ
inst✝¹ : CharP R p
inst✝ : Fact (Nat.Prime p)
⊢ (-1) ^ p ^ n + 1 = 0

tactic: rw [← add_pow_char_pow, add_left_neg, zero_pow (pow_pos (Fact.out (p := Nat.Prime p)).pos _)]
state_before: R : Type u_1
inst✝² : CommRing R
p n : ℕ
inst✝¹ : CharP R p
inst✝ : Fact (Nat.Prime p)
⊢ (-1) ^ p ^ n + 1 ^ p ^ n = 0
Theorem: CategoryTheory.Limits.biprod.mapBiprod_inv_map_desc
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Biproducts.lean

tactic: apply biprod.hom_ext' <;> simp [mapBiprod, ← F.map_comp]
state_before: C : Type u₁
inst✝⁶ : Category C
D : Type u₂
inst✝⁵ : Category D
inst✝⁴ : HasZeroMorphisms C
inst✝³ : HasZeroMorphisms D
F : C ⥤ D
inst✝² : PreservesZeroMorphisms F
X Y : C
inst✝¹ : HasBinaryBiproduct X Y
inst✝ : PreservesBinaryBiproduct X Y F
W : C
f : X ⟶ W
g : Y ⟶ W
⊢ (mapBiprod F X Y).inv ≫ F.map (desc f g) = desc (F.map f) (F.map g)
Theorem: ContinuousLinearMap.norm_id_le
File: Mathlib/Analysis/NormedSpace/OperatorNorm.lean

tactic: simp
state_before: 𝕜 : Type u_2
𝕜₂ : Type ?u.411250
𝕜₃ : Type ?u.411253
E : Type u_1
Eₗ : Type ?u.411259
F : Type ?u.411262
Fₗ : Type ?u.411265
G : Type ?u.411268
Gₗ : Type ?u.411271
𝓕 : Type ?u.411274
inst✝¹⁷ : SeminormedAddCommGroup E
inst✝¹⁶ : SeminormedAddCommGroup Eₗ
inst✝¹⁵ : SeminormedAddCommGroup F
inst✝¹⁴ : SeminormedAddCommGroup Fₗ
inst✝¹³ : SeminormedAddCommGroup G
inst✝¹² : SeminormedAddCommGroup Gₗ
inst✝¹¹ : NontriviallyNormedField 𝕜
inst✝¹⁰ : NontriviallyNormedField 𝕜₂
inst✝⁹ : NontriviallyNormedField 𝕜₃
inst✝⁸ : NormedSpace 𝕜 E
inst✝⁷ : NormedSpace 𝕜 Eₗ
inst✝⁶ : NormedSpace 𝕜₂ F
inst✝⁵ : NormedSpace 𝕜 Fₗ
inst✝⁴ : NormedSpace 𝕜₃ G
inst✝³ : NormedSpace 𝕜 Gₗ
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
σ₁₃ : 𝕜 →+* 𝕜₃
inst✝² : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝¹ : RingHomIsometric σ₁₂
inst✝ : RingHomIsometric σ₂₃
f g : E →SL[σ₁₂] F
h : F →SL[σ₂₃] G
x✝ x : E
⊢ ‖↑(id 𝕜 E) x‖ ≤ 1 * ‖x‖
Theorem: Ideal.map_eq_top_or_isMaximal_of_surjective
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: refine' or_iff_not_imp_left.2 fun ne_top => ⟨⟨fun h => ne_top h, fun J hJ => _⟩⟩
state_before: R : Type u
S : Type v
F : Type u_1
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : RingHomClass F R S
f : F
I✝ : Ideal R
hf : Function.Surjective ↑f
I : Ideal R
H : IsMaximal I
⊢ map f I = ⊤ ∨ IsMaximal (map f I)

tactic: refine'
  (relIsoOfSurjective f hf).injective
    (Subtype.ext_iff.2 (Eq.trans (H.1.2 (comap f J) (lt_of_le_of_ne _ _)) comap_top.symm))
state_before: R : Type u
S : Type v
F : Type u_1
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : RingHomClass F R S
f : F
I✝ : Ideal R
hf : Function.Surjective ↑f
I : Ideal R
H : IsMaximal I
ne_top : ¬map f I = ⊤
J : Ideal S
hJ : map f I < J
⊢ J = ⊤

tactic: exact map_le_iff_le_comap.1 (le_of_lt hJ)
state_before: case refine'_1
R : Type u
S : Type v
F : Type u_1
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : RingHomClass F R S
f : F
I✝ : Ideal R
hf : Function.Surjective ↑f
I : Ideal R
H : IsMaximal I
ne_top : ¬map f I = ⊤
J : Ideal S
hJ : map f I < J
⊢ I ≤ comap f J

tactic: exact fun h => hJ.right (le_map_of_comap_le_of_surjective f hf (le_of_eq h.symm))
state_before: case refine'_2
R : Type u
S : Type v
F : Type u_1
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : RingHomClass F R S
f : F
I✝ : Ideal R
hf : Function.Surjective ↑f
I : Ideal R
H : IsMaximal I
ne_top : ¬map f I = ⊤
J : Ideal S
hJ : map f I < J
⊢ I ≠ comap f J
Theorem: Quiver.cast_eq_of_cons_eq_cons
File: Mathlib/Combinatorics/Quiver/Cast.lean

tactic: rw [Path.cast_eq_iff_heq]
state_before: U : Type u_1
inst✝ : Quiver U
u v v' w : U
p : Path u v
p' : Path u v'
e : v ⟶ w
e' : v' ⟶ w
h : cons p e = cons p' e'
⊢ Path.cast (_ : u = u) (_ : v = v') p = p'

tactic: exact heq_of_cons_eq_cons h
state_before: U : Type u_1
inst✝ : Quiver U
u v v' w : U
p : Path u v
p' : Path u v'
e : v ⟶ w
e' : v' ⟶ w
h : cons p e = cons p' e'
⊢ HEq p p'
Theorem: List.map₂Right_nil_left
File: Mathlib/Data/List/Basic.lean

tactic: cases bs <;> rfl
state_before: ι : Type ?u.475243
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : Option α → β → γ
a : α
as : List α
b : β
bs : List β
⊢ map₂Right f [] bs = map (f none) bs
Theorem: YoungDiagram.mem_iff_lt_rowLen
File: Mathlib/Combinatorics/Young/YoungDiagram.lean

tactic: rw [rowLen, Nat.lt_find_iff]
state_before: μ : YoungDiagram
i j : ℕ
⊢ (i, j) ∈ μ ↔ j < rowLen μ i

tactic: push_neg
state_before: μ : YoungDiagram
i j : ℕ
⊢ (i, j) ∈ μ ↔ ∀ (m : ℕ), m ≤ j → ¬¬(i, m) ∈ μ

tactic: exact ⟨fun h _ hmj => μ.up_left_mem (by rfl) hmj h, fun h => h _ (by rfl)⟩
state_before: μ : YoungDiagram
i j : ℕ
⊢ (i, j) ∈ μ ↔ ∀ (m : ℕ), m ≤ j → (i, m) ∈ μ

tactic: rfl
state_before: μ : YoungDiagram
i j : ℕ
h : (i, j) ∈ μ
x✝ : ℕ
hmj : x✝ ≤ j
⊢ i ≤ i

tactic: rfl
state_before: μ : YoungDiagram
i j : ℕ
h : ∀ (m : ℕ), m ≤ j → (i, m) ∈ μ
⊢ j ≤ j
Theorem: List.length_eraseP_of_mem
File: Std/Data/List/Lemmas.lean

tactic: let ⟨_, l₁, l₂, _, _, e₁, e₂⟩ := exists_of_eraseP al pa
state_before: α✝ : Type u_1
a : α✝
l : List α✝
p : α✝ → Bool
al : a ∈ l
pa : p a = true
⊢ length (eraseP p l) = pred (length l)

tactic: rw [e₂]
state_before: α✝ : Type u_1
a : α✝
l : List α✝
p : α✝ → Bool
al : a ∈ l
pa : p a = true
w✝ : α✝
l₁ l₂ : List α✝
left✝¹ : ∀ (b : α✝), b ∈ l₁ → ¬p b = true
left✝ : p w✝ = true
e₁ : l = l₁ ++ w✝ :: l₂
e₂ : eraseP p l = l₁ ++ l₂
⊢ length (eraseP p l) = pred (length l)

tactic: simp [length_append, e₁]
state_before: α✝ : Type u_1
a : α✝
l : List α✝
p : α✝ → Bool
al : a ∈ l
pa : p a = true
w✝ : α✝
l₁ l₂ : List α✝
left✝¹ : ∀ (b : α✝), b ∈ l₁ → ¬p b = true
left✝ : p w✝ = true
e₁ : l = l₁ ++ w✝ :: l₂
e₂ : eraseP p l = l₁ ++ l₂
⊢ length (l₁ ++ l₂) = pred (length l)

tactic: rfl
state_before: α✝ : Type u_1
a : α✝
l : List α✝
p : α✝ → Bool
al : a ∈ l
pa : p a = true
w✝ : α✝
l₁ l₂ : List α✝
left✝¹ : ∀ (b : α✝), b ∈ l₁ → ¬p b = true
left✝ : p w✝ = true
e₁ : l = l₁ ++ w✝ :: l₂
e₂ : eraseP p l = l₁ ++ l₂
⊢ length l₁ + length l₂ = pred (length l₁ + succ (length l₂))