tasksource/leandojo huggingface dataset:
Theorem: Path.ext
File: Mathlib/Topology/PathConnected.lean

tactic: rintro ⟨⟨x, h11⟩, h12, h13⟩ ⟨⟨x, h21⟩, h22, h23⟩ rfl
state_before: X : Type u_1
Y : Type ?u.11489
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type ?u.11504
⊢ ∀ {γ₁ γ₂ : Path x y}, ↑γ₁ = ↑γ₂ → γ₁ = γ₂

tactic: rfl
state_before: case mk.mk.mk.mk
X : Type u_1
Y : Type ?u.11489
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x✝ y z : X
ι : Type ?u.11504
x : ↑I → X
h11 : Continuous x
h12 : ContinuousMap.toFun (ContinuousMap.mk x) 0 = x✝
h13 : ContinuousMap.toFun (ContinuousMap.mk x) 1 = y
h21 : Continuous ↑{ toContinuousMap := ContinuousMap.mk x, source' := h12, target' := h13 }
h22 :
  ContinuousMap.toFun (ContinuousMap.mk ↑{ toContinuousMap := ContinuousMap.mk x, source' := h12, target' := h13 }) 0 =
    x✝
h23 :
  ContinuousMap.toFun (ContinuousMap.mk ↑{ toContinuousMap := ContinuousMap.mk x, source' := h12, target' := h13 }) 1 =
    y
⊢ { toContinuousMap := ContinuousMap.mk x, source' := h12, target' := h13 } =
    { toContinuousMap := ContinuousMap.mk ↑{ toContinuousMap := ContinuousMap.mk x, source' := h12, target' := h13 },
      source' := h22, target' := h23 }
Theorem: IsFiniteMeasure.lintegral_lt_top_of_bounded_to_eNNReal
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: cases' f_bdd with c hc
state_before: α✝ : Type ?u.1753837
β : Type ?u.1753840
γ : Type ?u.1753843
δ : Type ?u.1753846
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
μ_fin : IsFiniteMeasure μ
f : α → ℝ≥0∞
f_bdd : ∃ c, ∀ (x : α), f x ≤ ↑c
⊢ (∫⁻ (x : α), f x ∂μ) < ⊤

tactic: apply lt_of_le_of_lt (@lintegral_mono _ _ μ _ _ hc)
state_before: case intro
α✝ : Type ?u.1753837
β : Type ?u.1753840
γ : Type ?u.1753843
δ : Type ?u.1753846
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
μ_fin : IsFiniteMeasure μ
f : α → ℝ≥0∞
c : ℝ≥0
hc : ∀ (x : α), f x ≤ ↑c
⊢ (∫⁻ (x : α), f x ∂μ) < ⊤

tactic: rw [lintegral_const]
state_before: case intro
α✝ : Type ?u.1753837
β : Type ?u.1753840
γ : Type ?u.1753843
δ : Type ?u.1753846
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
μ_fin : IsFiniteMeasure μ
f : α → ℝ≥0∞
c : ℝ≥0
hc : ∀ (x : α), f x ≤ ↑c
⊢ (∫⁻ (a : α), ↑c ∂μ) < ⊤

tactic: exact ENNReal.mul_lt_top ENNReal.coe_lt_top.ne μ_fin.measure_univ_lt_top.ne
state_before: case intro
α✝ : Type ?u.1753837
β : Type ?u.1753840
γ : Type ?u.1753843
δ : Type ?u.1753846
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
μ_fin : IsFiniteMeasure μ
f : α → ℝ≥0∞
c : ℝ≥0
hc : ∀ (x : α), f x ≤ ↑c
⊢ ↑c * ↑↑μ univ < ⊤
Theorem: ContinuousAffineMap.decomp
File: Mathlib/Analysis/NormedSpace/ContinuousAffineMap.lean

tactic: rcases f with ⟨f, h⟩
state_before: 𝕜 : Type ?u.87212
R : Type u_1
V : Type u_2
W : Type u_3
W₂ : Type ?u.87224
P : Type ?u.87227
Q : Type ?u.87230
Q₂ : Type ?u.87233
inst✝¹⁶ : NormedAddCommGroup V
inst✝¹⁵ : MetricSpace P
inst✝¹⁴ : NormedAddTorsor V P
inst✝¹³ : NormedAddCommGroup W
inst✝¹² : MetricSpace Q
inst✝¹¹ : NormedAddTorsor W Q
inst✝¹⁰ : NormedAddCommGroup W₂
inst✝⁹ : MetricSpace Q₂
inst✝⁸ : NormedAddTorsor W₂ Q₂
inst✝⁷ : NormedField R
inst✝⁶ : NormedSpace R V
inst✝⁵ : NormedSpace R W
inst✝⁴ : NormedSpace R W₂
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedSpace 𝕜 V
inst✝¹ : NormedSpace 𝕜 W
inst✝ : NormedSpace 𝕜 W₂
f : V →A[R] W
⊢ ↑f = ↑(contLinear f) + Function.const V (↑f 0)

tactic: rw [coe_mk_const_linear_eq_linear, coe_mk, f.decomp, Pi.add_apply, LinearMap.map_zero, zero_add,
  ← Function.const_def]
state_before: case mk
𝕜 : Type ?u.87212
R : Type u_1
V : Type u_2
W : Type u_3
W₂ : Type ?u.87224
P : Type ?u.87227
Q : Type ?u.87230
Q₂ : Type ?u.87233
inst✝¹⁶ : NormedAddCommGroup V
inst✝¹⁵ : MetricSpace P
inst✝¹⁴ : NormedAddTorsor V P
inst✝¹³ : NormedAddCommGroup W
inst✝¹² : MetricSpace Q
inst✝¹¹ : NormedAddTorsor W Q
inst✝¹⁰ : NormedAddCommGroup W₂
inst✝⁹ : MetricSpace Q₂
inst✝⁸ : NormedAddTorsor W₂ Q₂
inst✝⁷ : NormedField R
inst✝⁶ : NormedSpace R V
inst✝⁵ : NormedSpace R W
inst✝⁴ : NormedSpace R W₂
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedSpace 𝕜 V
inst✝¹ : NormedSpace 𝕜 W
inst✝ : NormedSpace 𝕜 W₂
f : V →ᵃ[R] W
h : Continuous f.toFun
⊢ ↑{ toAffineMap := f, cont := h } =
    ↑(contLinear { toAffineMap := f, cont := h }) + Function.const V (↑{ toAffineMap := f, cont := h } 0)
Theorem: Cardinal.lift_continuum
File: Mathlib/SetTheory/Cardinal/Continuum.lean

tactic: rw [← two_power_aleph0, lift_two_power, lift_aleph0, two_power_aleph0]
state_before: ⊢ lift 𝔠 = 𝔠
Theorem: card_commutatorSet_closureCommutatorRepresentatives
File: Mathlib/GroupTheory/Abelianization.lean

tactic: rw [← image_commutatorSet_closureCommutatorRepresentatives G]
state_before: G : Type u
inst✝ : Group G
⊢ Nat.card ↑(commutatorSet { x // x ∈ closureCommutatorRepresentatives G }) = Nat.card ↑(commutatorSet G)

tactic: exact Nat.card_congr (Equiv.Set.image _ _ (subtype_injective _))
state_before: G : Type u
inst✝ : Group G
⊢ Nat.card ↑(commutatorSet { x // x ∈ closureCommutatorRepresentatives G }) =
    Nat.card
      ↑(↑(Subgroup.subtype (closureCommutatorRepresentatives G)) ''
          commutatorSet { x // x ∈ closureCommutatorRepresentatives G })
Theorem: WithBot.image_coe_Iio
File: Mathlib/Data/Set/Intervals/WithBotTop.lean

tactic: rw [← preimage_coe_Iio, image_preimage_eq_inter_range, range_coe, inter_comm, Ioi_inter_Iio]
state_before: α : Type u_1
inst✝ : PartialOrder α
a b : α
⊢ some '' Iio a = Ioo ⊥ ↑a
Theorem: Polynomial.integralNormalization_zero
File: Mathlib/Data/Polynomial/IntegralNormalization.lean

tactic: simp [integralNormalization]
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
⊢ integralNormalization 0 = 0
Theorem: List.trop_minimum
File: Mathlib/Algebra/Tropical/BigOperators.lean

tactic: induction' l with hd tl IH
state_before: R : Type u_1
S : Type ?u.18757
inst✝ : LinearOrder R
l : List R
⊢ trop (minimum l) = sum (map (trop ∘ WithTop.some) l)

tactic: simp
state_before: case nil
R : Type u_1
S : Type ?u.18757
inst✝ : LinearOrder R
⊢ trop (minimum []) = sum (map (trop ∘ WithTop.some) [])

tactic: simp [List.minimum_cons, ← IH]
state_before: case cons
R : Type u_1
S : Type ?u.18757
inst✝ : LinearOrder R
hd : R
tl : List R
IH : trop (minimum tl) = sum (map (trop ∘ WithTop.some) tl)
⊢ trop (minimum (hd :: tl)) = sum (map (trop ∘ WithTop.some) (hd :: tl))
Theorem: symmDiff_eq_top
File: Mathlib/Order/SymmDiff.lean

tactic: rw [symmDiff_eq', ← compl_inf, inf_eq_top_iff, compl_eq_top, isCompl_iff, disjoint_iff,
  codisjoint_iff, and_comm]
state_before: ι : Type ?u.89407
α : Type u_1
β : Type ?u.89413
π : ι → Type ?u.89418
inst✝ : BooleanAlgebra α
a b c d : α
⊢ a ∆ b = ⊤ ↔ IsCompl a b
Theorem: inner_smul_real_right
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [inner_smul_right, Algebra.smul_def]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1390293
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : E
r : ℝ
⊢ inner x (↑r • y) = r • inner x y

tactic: rfl
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1390293
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : E
r : ℝ
⊢ ↑r * inner x y = ↑(algebraMap ℝ 𝕜) r * inner x y
Theorem: Option.liftOrGet_choice
File: Mathlib/Data/Option/Basic.lean

tactic: simpa [liftOrGet] using h a b
state_before: α : Type u_1
β : Type ?u.17342
γ : Type ?u.17345
δ : Type ?u.17348
f : α → α → α
h : ∀ (a b : α), f a b = a ∨ f a b = b
a b : α
⊢ liftOrGet f (some a) (some b) = some a ∨ liftOrGet f (some a) (some b) = some b
Theorem: Ordnode.Valid'.node4L_lemma₂
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: linarith
state_before: α : Type ?u.281928
inst✝ : Preorder α
b c d : ℕ
mr₂ : b + c + 1 ≤ 3 * d
⊢ c ≤ 3 * d
Theorem: MeasureTheory.integral_Ioi_of_hasDerivAt_of_tendsto'
File: Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean

tactic: refine integral_Ioi_of_hasDerivAt_of_tendsto (fun x hx ↦ ?_) (fun x hx => hderiv x hx.out.le)
  f'int hf
state_before: E : Type u_1
f f' : ℝ → E
g g' : ℝ → ℝ
a b l : ℝ
m : E
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
hderiv : ∀ (x : ℝ), x ∈ Ici a → HasDerivAt f (f' x) x
f'int : IntegrableOn f' (Ioi a)
hf : Tendsto f atTop (𝓝 m)
⊢ (∫ (x : ℝ) in Ioi a, f' x) = m - f a

tactic: exact (hderiv x hx).continuousAt.continuousWithinAt
state_before: E : Type u_1
f f' : ℝ → E
g g' : ℝ → ℝ
a b l : ℝ
m : E
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
hderiv : ∀ (x : ℝ), x ∈ Ici a → HasDerivAt f (f' x) x
f'int : IntegrableOn f' (Ioi a)
hf : Tendsto f atTop (𝓝 m)
x : ℝ
hx : x ∈ Ici a
⊢ ContinuousWithinAt f (Ici a) x
Theorem: Int.csInf_mem
File: Mathlib/Data/Int/ConditionallyCompleteOrder.lean

tactic: convert (leastOfBdd _ (Classical.choose_spec h2) h1).2.1
state_before: s : Set ℤ
h1 : Set.Nonempty s
h2 : BddBelow s
⊢ sInf s ∈ s

tactic: exact dif_pos ⟨h1, h2⟩
state_before: case h.e'_4
s : Set ℤ
h1 : Set.Nonempty s
h2 : BddBelow s
⊢ sInf s = ↑(leastOfBdd (choose h2) (_ : choose h2 ∈ lowerBounds s) h1)
Theorem: IsMetricSeparated.union_left
File: Mathlib/Topology/MetricSpace/MetricSeparated.lean

tactic: rcases h, h' with ⟨⟨r, r0, hr⟩, ⟨r', r0', hr'⟩⟩
state_before: X : Type u_1
inst✝ : EMetricSpace X
s t : Set X
x y : X
s' : Set X
h : IsMetricSeparated s t
h' : IsMetricSeparated s' t
⊢ IsMetricSeparated (s ∪ s') t

tactic: refine' ⟨min r r', _, fun x hx y hy => hx.elim _ _⟩
state_before: case intro.intro.intro.intro
X : Type u_1
inst✝ : EMetricSpace X
s t : Set X
x y : X
s' : Set X
r : ENNReal
r0 : r ≠ 0
hr : ∀ (x : X), x ∈ s → ∀ (y : X), y ∈ t → r ≤ edist x y
r' : ENNReal
r0' : r' ≠ 0
hr' : ∀ (x : X), x ∈ s' → ∀ (y : X), y ∈ t → r' ≤ edist x y
⊢ IsMetricSeparated (s ∪ s') t

tactic: rw [← pos_iff_ne_zero] at r0 r0'⊢
state_before: case intro.intro.intro.intro.refine'_1
X : Type u_1
inst✝ : EMetricSpace X
s t : Set X
x y : X
s' : Set X
r : ENNReal
r0 : r ≠ 0
hr : ∀ (x : X), x ∈ s → ∀ (y : X), y ∈ t → r ≤ edist x y
r' : ENNReal
r0' : r' ≠ 0
hr' : ∀ (x : X), x ∈ s' → ∀ (y : X), y ∈ t → r' ≤ edist x y
⊢ min r r' ≠ 0

tactic: exact lt_min r0 r0'
state_before: case intro.intro.intro.intro.refine'_1
X : Type u_1
inst✝ : EMetricSpace X
s t : Set X
x y : X
s' : Set X
r : ENNReal
r0 : 0 < r
hr : ∀ (x : X), x ∈ s → ∀ (y : X), y ∈ t → r ≤ edist x y
r' : ENNReal
r0' : 0 < r'
hr' : ∀ (x : X), x ∈ s' → ∀ (y : X), y ∈ t → r' ≤ edist x y
⊢ 0 < min r r'

tactic: exact fun hx => (min_le_left _ _).trans (hr _ hx _ hy)
state_before: case intro.intro.intro.intro.refine'_2
X : Type u_1
inst✝ : EMetricSpace X
s t : Set X
x✝ y✝ : X
s' : Set X
r : ENNReal
r0 : r ≠ 0
hr : ∀ (x : X), x ∈ s → ∀ (y : X), y ∈ t → r ≤ edist x y
r' : ENNReal
r0' : r' ≠ 0
hr' : ∀ (x : X), x ∈ s' → ∀ (y : X), y ∈ t → r' ≤ edist x y
x : X
hx : x ∈ s ∪ s'
y : X
hy : y ∈ t
⊢ x ∈ s → min r r' ≤ edist x y

tactic: exact fun hx => (min_le_right _ _).trans (hr' _ hx _ hy)
state_before: case intro.intro.intro.intro.refine'_3
X : Type u_1
inst✝ : EMetricSpace X
s t : Set X
x✝ y✝ : X
s' : Set X
r : ENNReal
r0 : r ≠ 0
hr : ∀ (x : X), x ∈ s → ∀ (y : X), y ∈ t → r ≤ edist x y
r' : ENNReal
r0' : r' ≠ 0
hr' : ∀ (x : X), x ∈ s' → ∀ (y : X), y ∈ t → r' ≤ edist x y
x : X
hx : x ∈ s ∪ s'
y : X
hy : y ∈ t
⊢ x ∈ s' → min r r' ≤ edist x y
Theorem: ConvexOn.translate_left
File: Mathlib/Analysis/Convex/Function.lean

tactic: simpa only [add_comm c] using hf.translate_right c
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.131601
α : Type ?u.131604
β : Type u_3
ι : Type ?u.131610
inst✝⁶ : OrderedSemiring 𝕜
inst✝⁵ : AddCommMonoid E
inst✝⁴ : AddCommMonoid F
inst✝³ : OrderedAddCommMonoid α
inst✝² : OrderedAddCommMonoid β
inst✝¹ : Module 𝕜 E
inst✝ : SMul 𝕜 β
s : Set E
f : E → β
hf : ConvexOn 𝕜 s f
c : E
⊢ ConvexOn 𝕜 ((fun z => c + z) ⁻¹' s) (f ∘ fun z => z + c)
Theorem: SimpleGraph.ComponentCompl.pairwise_disjoint
File: Mathlib/Combinatorics/SimpleGraph/Ends/Defs.lean

tactic: rintro C D ne
state_before: V : Type u
G : SimpleGraph V
K L L' M : Set V
⊢ Pairwise fun C D => Disjoint ↑C ↑D

tactic: rw [Set.disjoint_iff]
state_before: V : Type u
G : SimpleGraph V
K L L' M : Set V
C D : ComponentCompl G K
ne : C ≠ D
⊢ Disjoint ↑C ↑D

tactic: exact fun u ⟨uC, uD⟩ => ne (uC.choose_spec.symm.trans uD.choose_spec)
state_before: V : Type u
G : SimpleGraph V
K L L' M : Set V
C D : ComponentCompl G K
ne : C ≠ D
⊢ ↑C ∩ ↑D ⊆ ∅
Theorem: Real.sign_inv
File: Mathlib/Data/Real/Sign.lean

tactic: obtain hn | rfl | hp := lt_trichotomy r (0 : ℝ)
state_before: r : ℝ
⊢ sign r⁻¹ = sign r

tactic: rw [sign_of_neg hn, sign_of_neg (inv_lt_zero.mpr hn)]
state_before: case inl
r : ℝ
hn : r < 0
⊢ sign r⁻¹ = sign r

tactic: rw [sign_zero, inv_zero, sign_zero]
state_before: case inr.inl

⊢ sign 0⁻¹ = sign 0

tactic: rw [sign_of_pos hp, sign_of_pos (inv_pos.mpr hp)]
state_before: case inr.inr
r : ℝ
hp : 0 < r
⊢ sign r⁻¹ = sign r
Theorem: Complex.linearEquiv_det_conjAe
File: Mathlib/Data/Complex/Determinant.lean

tactic: rw [← Units.eq_iff, LinearEquiv.coe_det, AlgEquiv.toLinearEquiv_toLinearMap, det_conjAe,
  Units.coe_neg_one]
state_before: ⊢ ↑LinearEquiv.det (AlgEquiv.toLinearEquiv conjAe) = -1
Theorem: List.cons_diff_of_not_mem
File: Std/Data/List/Lemmas.lean

tactic: rw [cons_diff, if_neg h]
state_before: α : Type u_1
inst✝ : DecidableEq α
a : α
l₂ : List α
h : ¬a ∈ l₂
l₁ : List α
⊢ List.diff (a :: l₁) l₂ = a :: List.diff l₁ l₂
Theorem: Set.image_mul_left
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: rw [image_eq_preimage_of_inverse] <;> intro c <;> simp
state_before: F : Type ?u.121388
α : Type u_1
β : Type ?u.121394
γ : Type ?u.121397
inst✝ : Group α
s t : Set α
a b : α
⊢ (fun x x_1 => x * x_1) a '' t = (fun x x_1 => x * x_1) a⁻¹ ⁻¹' t
Theorem: Real.ind_mk
File: Mathlib/Data/Real/Basic.lean

tactic: cases' x with x
state_before: x✝ y : ℝ
C : ℝ → Prop
x : ℝ
h : ∀ (y : CauSeq ℚ abs), C (mk y)
⊢ C x

tactic: induction' x using Quot.induction_on with x
state_before: case ofCauchy
x✝ y : ℝ
C : ℝ → Prop
h : ∀ (y : CauSeq ℚ abs), C (mk y)
x : Cauchy abs
⊢ C { cauchy := x }

tactic: exact h x
state_before: case ofCauchy.h
x✝ y : ℝ
C : ℝ → Prop
h : ∀ (y : CauSeq ℚ abs), C (mk y)
x : CauSeq ℚ abs
⊢ C { cauchy := Quot.mk Setoid.r x }
Theorem: Ordinal.exists_of_lt_mex
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: by_contra' ha'
state_before: α : Type ?u.376990
β : Type ?u.376993
γ : Type ?u.376996
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u_1
f : ι → Ordinal
a : Ordinal
ha : a < mex f
⊢ ∃ i, f i = a

tactic: exact ha.not_le (mex_le_of_ne ha')
state_before: α : Type ?u.376990
β : Type ?u.376993
γ : Type ?u.376996
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u_1
f : ι → Ordinal
a : Ordinal
ha : a < mex f
ha' : ∀ (i : ι), f i ≠ a
⊢ False
Theorem: CategoryTheory.Arrow.hom.congr_left
File: Mathlib/CategoryTheory/Arrow.lean

tactic: rw [h]
state_before: T : Type u
inst✝ : Category T
f g : Arrow T
φ₁ φ₂ : f ⟶ g
h : φ₁ = φ₂
⊢ φ₁.left = φ₂.left
Theorem: contDiff_top_iff_fderiv
File: Mathlib/Analysis/Calculus/ContDiffDef.lean

tactic: simp only [← contDiffOn_univ, ← differentiableOn_univ, ← fderivWithin_univ]
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
⊢ ContDiff 𝕜 ⊤ f ↔ Differentiable 𝕜 f ∧ ContDiff 𝕜 ⊤ fun y => fderiv 𝕜 f y

tactic: rw [contDiffOn_top_iff_fderivWithin uniqueDiffOn_univ]
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
⊢ ContDiffOn 𝕜 ⊤ f univ ↔ DifferentiableOn 𝕜 f univ ∧ ContDiffOn 𝕜 ⊤ (fun y => fderivWithin 𝕜 f univ y) univ
Theorem: pochhammer_nat_eq_descFactorial
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

tactic: cases' b with b
state_before: S : Type u
inst✝ : Semiring S
a b : ℕ
⊢ eval a (pochhammer ℕ b) = Nat.descFactorial (a + b - 1) b

tactic: rw [Nat.add_succ, Nat.succ_sub_succ, tsub_zero]
state_before: case succ
S : Type u
inst✝ : Semiring S
a b : ℕ
⊢ eval a (pochhammer ℕ (Nat.succ b)) = Nat.descFactorial (a + Nat.succ b - 1) (Nat.succ b)

tactic: cases a
state_before: case succ
S : Type u
inst✝ : Semiring S
a b : ℕ
⊢ eval a (pochhammer ℕ (Nat.succ b)) = Nat.descFactorial (a + b) (Nat.succ b)

tactic: rw [Nat.descFactorial_zero, pochhammer_zero, Polynomial.eval_one]
state_before: case zero
S : Type u
inst✝ : Semiring S
a : ℕ
⊢ eval a (pochhammer ℕ Nat.zero) = Nat.descFactorial (a + Nat.zero - 1) Nat.zero

tactic: simp only [Nat.zero_eq, ne_eq, Nat.succ_ne_zero, not_false_iff, pochhammer_ne_zero_eval_zero,
zero_add, Nat.descFactorial_succ, le_refl, tsub_eq_zero_of_le, zero_mul]
state_before: case succ.zero
S : Type u
inst✝ : Semiring S
b : ℕ
⊢ eval Nat.zero (pochhammer ℕ (Nat.succ b)) = Nat.descFactorial (Nat.zero + b) (Nat.succ b)

tactic: rw [Nat.succ_add, ← Nat.add_succ, Nat.add_descFactorial_eq_ascFactorial,
  pochhammer_nat_eq_ascFactorial]
state_before: case succ.succ
S : Type u
inst✝ : Semiring S
b n✝ : ℕ
⊢ eval (Nat.succ n✝) (pochhammer ℕ (Nat.succ b)) = Nat.descFactorial (Nat.succ n✝ + b) (Nat.succ b)
Theorem: Ordinal.type_subrel_lt
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: refine' Quotient.inductionOn o _
state_before: α : Type ?u.105581
β : Type ?u.105584
γ : Type ?u.105587
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
⊢ type (Subrel (fun x x_1 => x < x_1) {o' | o' < o}) = lift o

tactic: rintro ⟨α, r, wo⟩
state_before: α : Type ?u.105581
β : Type ?u.105584
γ : Type ?u.105587
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
⊢ ∀ (a : WellOrder),
    type (Subrel (fun x x_1 => x < x_1) {o' | o' < Quotient.mk isEquivalent a}) = lift (Quotient.mk isEquivalent a)

tactic: skip
state_before: case mk
α✝ : Type ?u.105581
β : Type ?u.105584
γ : Type ?u.105587
r✝ : α✝ → α✝ → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
α : Type u
r : α → α → Prop
wo : IsWellOrder α r
⊢ type (Subrel (fun x x_1 => x < x_1) {o' | o' < Quotient.mk isEquivalent { α := α, r := r, wo := wo }}) =
    lift (Quotient.mk isEquivalent { α := α, r := r, wo := wo })

tactic: apply Quotient.sound
state_before: case mk
α✝ : Type ?u.105581
β : Type ?u.105584
γ : Type ?u.105587
r✝ : α✝ → α✝ → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
α : Type u
r : α → α → Prop
wo : IsWellOrder α r
⊢ type (Subrel (fun x x_1 => x < x_1) {o' | o' < Quotient.mk isEquivalent { α := α, r := r, wo := wo }}) =
    lift (Quotient.mk isEquivalent { α := α, r := r, wo := wo })

tactic: constructor
state_before: case mk.a
α✝ : Type ?u.105581
β : Type ?u.105584
γ : Type ?u.105587
r✝ : α✝ → α✝ → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
α : Type u
r : α → α → Prop
wo : IsWellOrder α r
⊢ { α := ↑{o' | o' < Quotient.mk isEquivalent { α := α, r := r, wo := wo }},
      r := Subrel (fun x x_1 => x < x_1) {o' | o' < Quotient.mk isEquivalent { α := α, r := r, wo := wo }},
      wo :=
        (_ :
          IsWellOrder (↑{o' | o' < Quotient.mk isEquivalent { α := α, r := r, wo := wo }})
            (Subrel (fun x x_1 => x < x_1) {o' | o' < Quotient.mk isEquivalent { α := α, r := r, wo := wo }})) } ≈
    { α := ULift { α := α, r := r, wo := wo }.α, r := ULift.down ⁻¹'o { α := α, r := r, wo := wo }.r,
      wo := (_ : IsWellOrder (ULift { α := α, r := r, wo := wo }.α) (ULift.down ⁻¹'o { α := α, r := r, wo := wo }.r)) }

tactic: refine' ((RelIso.preimage Equiv.ulift r).trans (enumIso r).symm).symm
state_before: case mk.a.val
α✝ : Type ?u.105581
β : Type ?u.105584
γ : Type ?u.105587
r✝ : α✝ → α✝ → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
α : Type u
r : α → α → Prop
wo : IsWellOrder α r
⊢ Subrel (fun x x_1 => x < x_1) {o' | o' < Quotient.mk isEquivalent { α := α, r := r, wo := wo }} ≃r
    ULift.down ⁻¹'o { α := α, r := r, wo := wo }.r
Theorem: Function.Commute.comp_iterate
File: Mathlib/Logic/Function/Iterate.lean

tactic: induction' n with n ihn
state_before: α : Type u
β : Type v
f g : α → α
h : Commute f g
n : ℕ
⊢ (f ∘ g)^[n] = f^[n] ∘ g^[n]

tactic: funext x
state_before: case succ
α : Type u
β : Type v
f g : α → α
h : Commute f g
n : ℕ
ihn : (f ∘ g)^[n] = f^[n] ∘ g^[n]
⊢ (f ∘ g)^[Nat.succ n] = f^[Nat.succ n] ∘ g^[Nat.succ n]

tactic: simp only [ihn, (h.iterate_right n).eq, iterate_succ, comp_apply]
state_before: case succ.h
α : Type u
β : Type v
f g : α → α
h : Commute f g
n : ℕ
ihn : (f ∘ g)^[n] = f^[n] ∘ g^[n]
x : α
⊢ ((f ∘ g)^[Nat.succ n]) x = (f^[Nat.succ n] ∘ g^[Nat.succ n]) x

tactic: rfl
state_before: case zero
α : Type u
β : Type v
f g : α → α
h : Commute f g
⊢ (f ∘ g)^[Nat.zero] = f^[Nat.zero] ∘ g^[Nat.zero]
Theorem: Nat.choose_succ_self_right
File: Mathlib/Data/Nat/Choose/Basic.lean

tactic: rw [choose_succ_succ, choose_succ_self_right n, choose_self]
state_before: n : ℕ
⊢ choose (n + 1 + 1) (n + 1) = n + 1 + 1
Theorem: unitary.star_mem
File: Mathlib/Algebra/Star/Unitary.lean

tactic: rw [star_star, mul_star_self_of_mem hU]
state_before: R : Type u_1
inst✝¹ : Monoid R
inst✝ : StarSemigroup R
U : R
hU : U ∈ unitary R
⊢ star (star U) * star U = 1

tactic: rw [star_star, star_mul_self_of_mem hU]
state_before: R : Type u_1
inst✝¹ : Monoid R
inst✝ : StarSemigroup R
U : R
hU : U ∈ unitary R
⊢ star U * star (star U) = 1
Theorem: LinearMap.rank_comp_le_right
File: Mathlib/LinearAlgebra/Dimension.lean

tactic: simpa only [Cardinal.lift_id] using lift_rank_comp_le_right g f
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.1132953
inst✝¹⁰ : Ring K
inst✝⁹ : AddCommGroup V
inst✝⁸ : Module K V
inst✝⁷ : AddCommGroup V₁
inst✝⁶ : Module K V₁
inst✝⁵ : AddCommGroup V'
inst✝⁴ : Module K V'
inst✝³ : AddCommGroup V''
inst✝² : Module K V''
inst✝¹ : AddCommGroup V'₁
inst✝ : Module K V'₁
g : V →ₗ[K] V'
f : V' →ₗ[K] V'₁
⊢ rank (comp f g) ≤ rank g
Theorem: padicNormE.eq_of_norm_add_lt_right
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: rw [padicNormE.add_eq_max_of_ne hne]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
z1 z2 : ℚ_[p]
h : ‖z1 + z2‖ < ‖z2‖
hne : ¬‖z1‖ = ‖z2‖
⊢ ‖z1 + z2‖ ≥ ‖z2‖

tactic: apply le_max_right
state_before: p : ℕ
hp : Fact (Nat.Prime p)
z1 z2 : ℚ_[p]
h : ‖z1 + z2‖ < ‖z2‖
hne : ¬‖z1‖ = ‖z2‖
⊢ max ‖z1‖ ‖z2‖ ≥ ‖z2‖