tasksource/leandojo huggingface dataset:
Theorem: LocalHomeomorph.extend_preimage_mem_nhdsWithin
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

tactic: rwa [← map_extend_symm_nhdsWithin f I h, mem_map] at ht
state_before: 𝕜 : Type u_4
E : Type u_3
M : Type u_1
H : Type u_2
E' : Type ?u.157559
M' : Type ?u.157562
H' : Type ?u.157565
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
f f' : LocalHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
inst✝¹ : TopologicalSpace H'
inst✝ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
x✝ : M
s t : Set M
x : M
h : x ∈ f.source
ht : t ∈ 𝓝[s] x
⊢ ↑(LocalEquiv.symm (extend f I)) ⁻¹' t ∈ 𝓝[↑(LocalEquiv.symm (extend f I)) ⁻¹' s ∩ range ↑I] ↑(extend f I) x
Theorem: Filter.Eventually.curry
File: Mathlib/Order/Filter/Prod.lean

tactic: rcases eventually_prod_iff.1 h with ⟨pa, ha, pb, hb, h⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.9161
δ : Type ?u.9164
ι : Sort ?u.9167
s : Set α
t : Set β
f : Filter α
g : Filter β
la : Filter α
lb : Filter β
p : α × β → Prop
h : ∀ᶠ (x : α × β) in la ×ˢ lb, p x
⊢ ∀ᶠ (x : α) in la, ∀ᶠ (y : β) in lb, p (x, y)

tactic: exact ha.mono fun a ha => hb.mono fun b hb => h ha hb
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.9161
δ : Type ?u.9164
ι : Sort ?u.9167
s : Set α
t : Set β
f : Filter α
g : Filter β
la : Filter α
lb : Filter β
p : α × β → Prop
h✝ : ∀ᶠ (x : α × β) in la ×ˢ lb, p x
pa : α → Prop
ha : ∀ᶠ (x : α) in la, pa x
pb : β → Prop
hb : ∀ᶠ (y : β) in lb, pb y
h : ∀ {x : α}, pa x → ∀ {y : β}, pb y → p (x, y)
⊢ ∀ᶠ (x : α) in la, ∀ᶠ (y : β) in lb, p (x, y)
Theorem: Zsqrtd.norm_mul
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: simp only [norm, mul_im, mul_re]
state_before: d : ℤ
n m : ℤ√d
⊢ norm (n * m) = norm n * norm m

tactic: ring
state_before: d : ℤ
n m : ℤ√d
⊢ (n.re * m.re + d * n.im * m.im) * (n.re * m.re + d * n.im * m.im) -
      d * (n.re * m.im + n.im * m.re) * (n.re * m.im + n.im * m.re) =
    (n.re * n.re - d * n.im * n.im) * (m.re * m.re - d * m.im * m.im)
Theorem: MeasureTheory.Integrable.re
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: rw [← memℒp_one_iff_integrable] at hf ⊢
state_before: α : Type u_2
β : Type ?u.1194690
γ : Type ?u.1194693
δ : Type ?u.1194696
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β
inst✝¹ : NormedAddCommGroup γ
𝕜 : Type u_1
inst✝ : IsROrC 𝕜
f : α → 𝕜
hf : Integrable f
⊢ Integrable fun x => ↑IsROrC.re (f x)

tactic: exact hf.re
state_before: α : Type u_2
β : Type ?u.1194690
γ : Type ?u.1194693
δ : Type ?u.1194696
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β
inst✝¹ : NormedAddCommGroup γ
𝕜 : Type u_1
inst✝ : IsROrC 𝕜
f : α → 𝕜
hf : Memℒp f 1
⊢ Memℒp (fun x => ↑IsROrC.re (f x)) 1
Theorem: Equiv.Perm.mem_toList_iff
File: Mathlib/GroupTheory/Perm/Cycle/Concrete.lean

tactic: simp only [toList, mem_range, mem_map]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x y : α
⊢ y ∈ toList p x ↔ SameCycle p x y ∧ x ∈ support p

tactic: constructor
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x y : α
⊢ (∃ a, a < Finset.card (support (cycleOf p x)) ∧ ↑(p ^ a) x = y) ↔ SameCycle p x y ∧ x ∈ support p

tactic: rintro ⟨n, hx, rfl⟩
state_before: case mp
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x y : α
⊢ (∃ a, a < Finset.card (support (cycleOf p x)) ∧ ↑(p ^ a) x = y) → SameCycle p x y ∧ x ∈ support p

tactic: refine' ⟨⟨n, rfl⟩, _⟩
state_before: case mp.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x : α
n : ℕ
hx : n < Finset.card (support (cycleOf p x))
⊢ SameCycle p x (↑(p ^ n) x) ∧ x ∈ support p

tactic: contrapose! hx
state_before: case mp.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x : α
n : ℕ
hx : n < Finset.card (support (cycleOf p x))
⊢ x ∈ support p

tactic: rw [← support_cycleOf_eq_nil_iff] at hx
state_before: case mp.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x : α
n : ℕ
hx : ¬x ∈ support p
⊢ Finset.card (support (cycleOf p x)) ≤ n

tactic: simp [hx]
state_before: case mp.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x : α
n : ℕ
hx : support (cycleOf p x) = ∅
⊢ Finset.card (support (cycleOf p x)) ≤ n

tactic: rintro ⟨h, hx⟩
state_before: case mpr
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x y : α
⊢ SameCycle p x y ∧ x ∈ support p → ∃ a, a < Finset.card (support (cycleOf p x)) ∧ ↑(p ^ a) x = y

tactic: simpa using h.exists_pow_eq_of_mem_support hx
state_before: case mpr.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x y : α
h : SameCycle p x y
hx : x ∈ support p
⊢ ∃ a, a < Finset.card (support (cycleOf p x)) ∧ ↑(p ^ a) x = y
Theorem: Int.div_left_inj
File: Std/Data/Int/DivMod.lean

tactic: rw [← Int.mul_div_cancel' hda, ← Int.mul_div_cancel' hdb, h]
state_before: a b d : Int
hda : d ∣ a
hdb : d ∣ b
h : div a d = div b d
⊢ a = b
Theorem: Set.ncard_insert_of_mem
File: Mathlib/Data/Set/Ncard.lean

tactic: rw [insert_eq_of_mem h]
state_before: α : Type u_1
β : Type ?u.10918
s t : Set α
a b x y : α
f : α → β
h : a ∈ s
⊢ ncard (insert a s) = ncard s
Theorem: FrameHom.cancel_left
File: Mathlib/Order/Hom/CompleteLattice.lean

tactic: rw [← comp_apply, h, comp_apply]
state_before: F : Type ?u.65994
α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.66006
ι : Sort ?u.66009
κ : ι → Sort ?u.66014
inst✝³ : CompleteLattice α
inst✝² : CompleteLattice β
inst✝¹ : CompleteLattice γ
inst✝ : CompleteLattice δ
g : FrameHom β γ
f₁ f₂ : FrameHom α β
hg : Injective ↑g
h : comp g f₁ = comp g f₂
a : α
⊢ ↑g (↑f₁ a) = ↑g (↑f₂ a)
Theorem: Ordinal.cof_omega
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rw [← card_omega]
state_before: α : Type ?u.102339
r : α → α → Prop
⊢ cof ω ≤ ℵ₀

tactic: apply cof_le_card
state_before: α : Type ?u.102339
r : α → α → Prop
⊢ cof ω ≤ card ω
Theorem: Order.succ_le_succ_iff_of_not_isMax
File: Mathlib/Order/SuccPred/Basic.lean

tactic: rw [succ_le_iff_of_not_isMax ha, lt_succ_iff_of_not_isMax hb]
state_before: α : Type u_1
inst✝¹ : Preorder α
inst✝ : SuccOrder α
a b : α
ha : ¬IsMax a
hb : ¬IsMax b
⊢ succ a ≤ succ b ↔ a ≤ b
Theorem: PowerSeries.map_cos
File: Mathlib/RingTheory/PowerSeries/WellKnown.lean

tactic: ext
state_before: A : Type u_2
A' : Type u_1
inst✝⁷ : Ring A
inst✝⁶ : Ring A'
inst✝⁵ : Algebra ℚ A
inst✝⁴ : Algebra ℚ A'
inst✝³ : Ring A
inst✝² : Ring A'
inst✝¹ : Algebra ℚ A
inst✝ : Algebra ℚ A'
n : ℕ
f : A →+* A'
⊢ ↑(map f) (cos A) = cos A'

tactic: simp [cos, apply_ite f]
state_before: case h
A : Type u_2
A' : Type u_1
inst✝⁷ : Ring A
inst✝⁶ : Ring A'
inst✝⁵ : Algebra ℚ A
inst✝⁴ : Algebra ℚ A'
inst✝³ : Ring A
inst✝² : Ring A'
inst✝¹ : Algebra ℚ A
inst✝ : Algebra ℚ A'
n : ℕ
f : A →+* A'
n✝ : ℕ
⊢ ↑(coeff A' n✝) (↑(map f) (cos A)) = ↑(coeff A' n✝) (cos A')
Theorem: OrderIso.mulLeft₀'_symm
File: Mathlib/Algebra/Order/WithZero.lean

tactic: ext
state_before: α : Type u_1
a✝ b c d x y z : α
inst✝ : LinearOrderedCommGroupWithZero α
a : α
ha : a ≠ 0
⊢ symm (mulLeft₀' ha) = mulLeft₀' (_ : a⁻¹ ≠ 0)

tactic: rfl
state_before: case h.h
α : Type u_1
a✝ b c d x y z : α
inst✝ : LinearOrderedCommGroupWithZero α
a : α
ha : a ≠ 0
x✝ : α
⊢ ↑(symm (mulLeft₀' ha)) x✝ = ↑(mulLeft₀' (_ : a⁻¹ ≠ 0)) x✝
Theorem: Pi.card_Ico
File: Mathlib/Data/Pi/Interval.lean

tactic: rw [card_Ico_eq_card_Icc_sub_one, card_Icc]
state_before: ι : Type u_1
α : ι → Type u_2
inst✝⁴ : DecidableEq ι
inst✝³ : Fintype ι
inst✝² : (i : ι) → DecidableEq (α i)
inst✝¹ : (i : ι) → PartialOrder (α i)
inst✝ : (i : ι) → LocallyFiniteOrder (α i)
a b : (i : ι) → α i
⊢ Finset.card (Ico a b) = ∏ i : ι, Finset.card (Icc (a i) (b i)) - 1
Theorem: disjoint_closedBall_closedBall_iff
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

tactic: refine' ⟨fun h => lt_of_not_ge fun hxy => _, closedBall_disjoint_closedBall⟩
state_before: 𝕜 : Type ?u.219618
E : Type u_1
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x y z : E
δ ε : ℝ
hδ : 0 ≤ δ
hε : 0 ≤ ε
⊢ Disjoint (closedBall x δ) (closedBall y ε) ↔ δ + ε < dist x y

tactic: rw [add_comm] at hxy
state_before: 𝕜 : Type ?u.219618
E : Type u_1
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x y z : E
δ ε : ℝ
hδ : 0 ≤ δ
hε : 0 ≤ ε
h : Disjoint (closedBall x δ) (closedBall y ε)
hxy : δ + ε ≥ dist x y
⊢ False

tactic: obtain ⟨z, hxz, hzy⟩ := exists_dist_le_le hδ hε hxy
state_before: 𝕜 : Type ?u.219618
E : Type u_1
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x y z : E
δ ε : ℝ
hδ : 0 ≤ δ
hε : 0 ≤ ε
h : Disjoint (closedBall x δ) (closedBall y ε)
hxy : ε + δ ≥ dist x y
⊢ False

tactic: rw [dist_comm] at hxz
state_before: case intro.intro
𝕜 : Type ?u.219618
E : Type u_1
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x y z✝ : E
δ ε : ℝ
hδ : 0 ≤ δ
hε : 0 ≤ ε
h : Disjoint (closedBall x δ) (closedBall y ε)
hxy : ε + δ ≥ dist x y
z : E
hxz : dist x z ≤ δ
hzy : dist z y ≤ ε
⊢ False

tactic: exact h.le_bot ⟨hxz, hzy⟩
state_before: case intro.intro
𝕜 : Type ?u.219618
E : Type u_1
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x y z✝ : E
δ ε : ℝ
hδ : 0 ≤ δ
hε : 0 ≤ ε
h : Disjoint (closedBall x δ) (closedBall y ε)
hxy : ε + δ ≥ dist x y
z : E
hxz : dist z x ≤ δ
hzy : dist z y ≤ ε
⊢ False
Theorem: MeasureTheory.measure_of_cont_bdd_of_tendsto_indicator
File: Mathlib/MeasureTheory/Measure/Portmanteau.lean

tactic: have fs_lim' :
  ∀ ω, Tendsto (fun n : ℕ => (fs n ω : ℝ≥0)) atTop (𝓝 (indicator E (fun _ => (1 : ℝ≥0)) ω)) := by
  rw [tendsto_pi_nhds] at fs_lim
  exact fun ω => fs_lim ω
state_before: Ω : Type u_1
inst✝³ : MeasurableSpace Ω
inst✝² : TopologicalSpace Ω
inst✝¹ : OpensMeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
c : ℝ≥0
E : Set Ω
E_mble : MeasurableSet E
fs : ℕ → Ω →ᵇ ℝ≥0
fs_bdd : ∀ (n : ℕ) (ω : Ω), ↑(fs n) ω ≤ c
fs_lim : Tendsto (fun n => ↑(fs n)) atTop (𝓝 (indicator E fun x => 1))
⊢ Tendsto (fun n => ∫⁻ (ω : Ω), ↑(↑(fs n) ω) ∂μ) atTop (𝓝 (↑↑μ E))

tactic: apply measure_of_cont_bdd_of_tendsto_filter_indicator μ E_mble fs
  (eventually_of_forall fun n => eventually_of_forall (fs_bdd n)) (eventually_of_forall fs_lim')
state_before: Ω : Type u_1
inst✝³ : MeasurableSpace Ω
inst✝² : TopologicalSpace Ω
inst✝¹ : OpensMeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
c : ℝ≥0
E : Set Ω
E_mble : MeasurableSet E
fs : ℕ → Ω →ᵇ ℝ≥0
fs_bdd : ∀ (n : ℕ) (ω : Ω), ↑(fs n) ω ≤ c
fs_lim : Tendsto (fun n => ↑(fs n)) atTop (𝓝 (indicator E fun x => 1))
fs_lim' : ∀ (ω : Ω), Tendsto (fun n => ↑(fs n) ω) atTop (𝓝 (indicator E (fun x => 1) ω))
⊢ Tendsto (fun n => ∫⁻ (ω : Ω), ↑(↑(fs n) ω) ∂μ) atTop (𝓝 (↑↑μ E))

tactic: rw [tendsto_pi_nhds] at fs_lim
state_before: Ω : Type u_1
inst✝³ : MeasurableSpace Ω
inst✝² : TopologicalSpace Ω
inst✝¹ : OpensMeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
c : ℝ≥0
E : Set Ω
E_mble : MeasurableSet E
fs : ℕ → Ω →ᵇ ℝ≥0
fs_bdd : ∀ (n : ℕ) (ω : Ω), ↑(fs n) ω ≤ c
fs_lim : Tendsto (fun n => ↑(fs n)) atTop (𝓝 (indicator E fun x => 1))
⊢ ∀ (ω : Ω), Tendsto (fun n => ↑(fs n) ω) atTop (𝓝 (indicator E (fun x => 1) ω))

tactic: exact fun ω => fs_lim ω
state_before: Ω : Type u_1
inst✝³ : MeasurableSpace Ω
inst✝² : TopologicalSpace Ω
inst✝¹ : OpensMeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
c : ℝ≥0
E : Set Ω
E_mble : MeasurableSet E
fs : ℕ → Ω →ᵇ ℝ≥0
fs_bdd : ∀ (n : ℕ) (ω : Ω), ↑(fs n) ω ≤ c
fs_lim : ∀ (x : Ω), Tendsto (fun i => ↑(fs i) x) atTop (𝓝 (indicator E (fun x => 1) x))
⊢ ∀ (ω : Ω), Tendsto (fun n => ↑(fs n) ω) atTop (𝓝 (indicator E (fun x => 1) ω))
Theorem: MvPolynomial.constantCoeff_monomial
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: rw [constantCoeff_eq, coeff_monomial]
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 : MvPolynomial σ R
inst✝ : DecidableEq σ
d : σ →₀ ℕ
r : R
⊢ ↑constantCoeff (↑(monomial d) r) = if d = 0 then r else 0
Theorem: MvPolynomial.constantCoeff_comp_C
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: ext x
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 : MvPolynomial σ R
⊢ RingHom.comp constantCoeff C = RingHom.id R

tactic: exact constantCoeff_C σ x
state_before: case a
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 : MvPolynomial σ R
x : R
⊢ ↑(RingHom.comp constantCoeff C) x = ↑(RingHom.id R) x
Theorem: List.nthLe_take'
File: Mathlib/Data/List/Basic.lean

tactic: simp [le_refl]
state_before: ι : Type ?u.169117
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ L : List α
i j : ℕ
hi : i < length (take j L)
⊢ length (take j L) ≤ length L
Theorem: Real.Angle.cos_sub_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: induction θ using Real.Angle.induction_on
state_before: θ : Angle
⊢ cos (θ - ↑(π / 2)) = sin θ

tactic: exact Real.cos_sub_pi_div_two _
state_before: case h
x✝ : ℝ
⊢ cos (↑x✝ - ↑(π / 2)) = sin ↑x✝
Theorem: MeasureTheory.measurePreserving_mul_prod_inv_right
File: Mathlib/MeasureTheory/Group/Prod.lean

tactic: convert (measurePreserving_prod_div_swap ν μ).comp (measurePreserving_prod_mul_swap_right μ ν)
  using 1
state_before: G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulRightInvariant μ
inst✝ : IsMulRightInvariant ν
⊢ MeasurePreserving fun z => (z.fst * z.snd, z.fst⁻¹)

tactic: ext1 ⟨x, y⟩
state_before: case h.e'_5
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulRightInvariant μ
inst✝ : IsMulRightInvariant ν
⊢ (fun z => (z.fst * z.snd, z.fst⁻¹)) = (fun z => (z.snd, z.fst / z.snd)) ∘ fun z => (z.snd, z.fst * z.snd)

tactic: simp_rw [Function.comp_apply, div_mul_eq_div_div_swap, div_self', one_div]
state_before: case h.e'_5.h.mk
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulRightInvariant μ
inst✝ : IsMulRightInvariant ν
x y : G
⊢ ((x, y).fst * (x, y).snd, (x, y).fst⁻¹) = ((fun z => (z.snd, z.fst / z.snd)) ∘ fun z => (z.snd, z.fst * z.snd)) (x, y)
Theorem: List.sublistsLen_sublist_of_sublist
File: Mathlib/Data/List/Sublists.lean

tactic: induction' n with n IHn generalizing l₁ l₂
state_before: α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
n : ℕ
l₁ l₂ : List α
h : l₁ <+ l₂
⊢ sublistsLen n l₁ <+ sublistsLen n l₂

tactic: induction' h with l₁ l₂ a _ IH l₁ l₂ a s IH
state_before: case succ
α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
l₁✝ l₂✝ : List α
h✝ : l₁✝ <+ l₂✝
n : ℕ
IHn : ∀ {l₁ l₂ : List α}, l₁ <+ l₂ → sublistsLen n l₁ <+ sublistsLen n l₂
l₁ l₂ : List α
h : l₁ <+ l₂
⊢ sublistsLen (succ n) l₁ <+ sublistsLen (succ n) l₂

tactic: simp
state_before: case zero
α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
l₁✝ l₂✝ : List α
h✝ : l₁✝ <+ l₂✝
l₁ l₂ : List α
h : l₁ <+ l₂
⊢ sublistsLen zero l₁ <+ sublistsLen zero l₂

tactic: rfl
state_before: case succ.slnil
α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
l₁✝ l₂✝ : List α
h : l₁✝ <+ l₂✝
n : ℕ
IHn : ∀ {l₁ l₂ : List α}, l₁ <+ l₂ → sublistsLen n l₁ <+ sublistsLen n l₂
l₁ l₂ : List α
⊢ sublistsLen (succ n) [] <+ sublistsLen (succ n) []

tactic: refine' IH.trans _
state_before: case succ.cons
α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
l₁✝¹ l₂✝¹ : List α
h : l₁✝¹ <+ l₂✝¹
n : ℕ
IHn : ∀ {l₁ l₂ : List α}, l₁ <+ l₂ → sublistsLen n l₁ <+ sublistsLen n l₂
l₁✝ l₂✝ l₁ l₂ : List α
a : α
a✝ : l₁ <+ l₂
IH : sublistsLen (succ n) l₁ <+ sublistsLen (succ n) l₂
⊢ sublistsLen (succ n) l₁ <+ sublistsLen (succ n) (a :: l₂)

tactic: rw [sublistsLen_succ_cons]
state_before: case succ.cons
α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
l₁✝¹ l₂✝¹ : List α
h : l₁✝¹ <+ l₂✝¹
n : ℕ
IHn : ∀ {l₁ l₂ : List α}, l₁ <+ l₂ → sublistsLen n l₁ <+ sublistsLen n l₂
l₁✝ l₂✝ l₁ l₂ : List α
a : α
a✝ : l₁ <+ l₂
IH : sublistsLen (succ n) l₁ <+ sublistsLen (succ n) l₂
⊢ sublistsLen (succ n) l₂ <+ sublistsLen (succ n) (a :: l₂)

tactic: apply sublist_append_left
state_before: case succ.cons
α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
l₁✝¹ l₂✝¹ : List α
h : l₁✝¹ <+ l₂✝¹
n : ℕ
IHn : ∀ {l₁ l₂ : List α}, l₁ <+ l₂ → sublistsLen n l₁ <+ sublistsLen n l₂
l₁✝ l₂✝ l₁ l₂ : List α
a : α
a✝ : l₁ <+ l₂
IH : sublistsLen (succ n) l₁ <+ sublistsLen (succ n) l₂
⊢ sublistsLen (succ n) l₂ <+ sublistsLen (n + 1) l₂ ++ map (cons a) (sublistsLen n l₂)

tactic: simp [sublistsLen_succ_cons]
state_before: case succ.cons₂
α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
l₁✝¹ l₂✝¹ : List α
h : l₁✝¹ <+ l₂✝¹
n : ℕ
IHn : ∀ {l₁ l₂ : List α}, l₁ <+ l₂ → sublistsLen n l₁ <+ sublistsLen n l₂
l₁✝ l₂✝ l₁ l₂ : List α
a : α
s : l₁ <+ l₂
IH : sublistsLen (succ n) l₁ <+ sublistsLen (succ n) l₂
⊢ sublistsLen (succ n) (a :: l₁) <+ sublistsLen (succ n) (a :: l₂)

tactic: exact IH.append ((IHn s).map _)
state_before: case succ.cons₂
α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
l₁✝¹ l₂✝¹ : List α
h : l₁✝¹ <+ l₂✝¹
n : ℕ
IHn : ∀ {l₁ l₂ : List α}, l₁ <+ l₂ → sublistsLen n l₁ <+ sublistsLen n l₂
l₁✝ l₂✝ l₁ l₂ : List α
a : α
s : l₁ <+ l₂
IH : sublistsLen (succ n) l₁ <+ sublistsLen (succ n) l₂
⊢ sublistsLen (n + 1) l₁ ++ map (cons a) (sublistsLen n l₁) <+ sublistsLen (n + 1) l₂ ++ map (cons a) (sublistsLen n l₂)
Theorem: MvPFunctor.wDest'_wMk'
File: Mathlib/Data/PFunctor/Multivariate/W.lean

tactic: cases' x with a f
state_before: n : ℕ
P : MvPFunctor (n + 1)
α : TypeVec n
x : Obj P (α ::: W P α)
⊢ wDest' P (wMk' P x) = x

tactic: rw [wMk', wDest'_wMk, split_dropFun_lastFun]
state_before: case mk
n : ℕ
P : MvPFunctor (n + 1)
α : TypeVec n
a : P.A
f : B P a ⟹ α ::: W P α
⊢ wDest' P (wMk' P { fst := a, snd := f }) = { fst := a, snd := f }
Theorem: set_fintype_card_eq_univ_iff
File: Mathlib/Data/Fintype/Card.lean

tactic: rw [← Set.toFinset_card, Finset.card_eq_iff_eq_univ, ← Set.toFinset_univ, Set.toFinset_inj]
state_before: α : Type u_1
β : Type ?u.47280
γ : Type ?u.47283
inst✝¹ : Fintype α
s : Set α
inst✝ : Fintype ↑s
⊢ Fintype.card ↑s = Fintype.card α ↔ s = Set.univ
Theorem: Filter.tendsto_const_mul_atBot_iff
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simp only [← tendsto_neg_atTop_iff, ← mul_neg, tendsto_const_mul_atTop_iff, neg_neg]
state_before: ι : Type ?u.237721
ι' : Type ?u.237724
α : Type u_2
β : Type u_1
γ : Type ?u.237733
inst✝¹ : LinearOrderedField α
l : Filter β
f : β → α
r : α
inst✝ : NeBot l
⊢ Tendsto (fun x => r * f x) l atBot ↔ 0 < r ∧ Tendsto f l atBot ∨ r < 0 ∧ Tendsto f l atTop
Theorem: Complex.normSq_add
File: Mathlib/Data/Complex/Basic.lean

tactic: dsimp [normSq]
state_before: z w : ℂ
⊢ ↑normSq (z + w) = ↑normSq z + ↑normSq w + 2 * (z * ↑(starRingEnd ℂ) w).re

tactic: ring
state_before: z w : ℂ
⊢ (z.re + w.re) * (z.re + w.re) + (z.im + w.im) * (z.im + w.im) =
    z.re * z.re + z.im * z.im + (w.re * w.re + w.im * w.im) + 2 * (z.re * w.re - z.im * -w.im)
Theorem: DistribMulActionHom.toAddMonoidHom_injective
File: Mathlib/Algebra/Hom/GroupAction.lean

tactic: ext a
state_before: M' : Type ?u.120188
X : Type ?u.120191
inst✝²³ : SMul M' X
Y : Type ?u.120198
inst✝²² : SMul M' Y
Z : Type ?u.120205
inst✝²¹ : SMul M' Z
M : Type u_1
inst✝²⁰ : Monoid M
A : Type u_2
inst✝¹⁹ : AddMonoid A
inst✝¹⁸ : DistribMulAction M A
A' : Type ?u.120246
inst✝¹⁷ : AddGroup A'
inst✝¹⁶ : DistribMulAction M A'
B : Type u_3
inst✝¹⁵ : AddMonoid B
inst✝¹⁴ : DistribMulAction M B
B' : Type ?u.120548
inst✝¹³ : AddGroup B'
inst✝¹² : DistribMulAction M B'
C : Type ?u.120824
inst✝¹¹ : AddMonoid C
inst✝¹⁰ : DistribMulAction M C
R : Type ?u.120850
inst✝⁹ : Semiring R
inst✝⁸ : MulSemiringAction M R
R' : Type ?u.120877
inst✝⁷ : Ring R'
inst✝⁶ : MulSemiringAction M R'
S : Type ?u.121073
inst✝⁵ : Semiring S
inst✝⁴ : MulSemiringAction M S
S' : Type ?u.121100
inst✝³ : Ring S'
inst✝² : MulSemiringAction M S'
T : Type ?u.121296
inst✝¹ : Semiring T
inst✝ : MulSemiringAction M T
f g : A →+[M] B
h : ↑f = ↑g
⊢ f = g

tactic: exact FunLike.congr_fun h a
state_before: case a
M' : Type ?u.120188
X : Type ?u.120191
inst✝²³ : SMul M' X
Y : Type ?u.120198
inst✝²² : SMul M' Y
Z : Type ?u.120205
inst✝²¹ : SMul M' Z
M : Type u_1
inst✝²⁰ : Monoid M
A : Type u_2
inst✝¹⁹ : AddMonoid A
inst✝¹⁸ : DistribMulAction M A
A' : Type ?u.120246
inst✝¹⁷ : AddGroup A'
inst✝¹⁶ : DistribMulAction M A'
B : Type u_3
inst✝¹⁵ : AddMonoid B
inst✝¹⁴ : DistribMulAction M B
B' : Type ?u.120548
inst✝¹³ : AddGroup B'
inst✝¹² : DistribMulAction M B'
C : Type ?u.120824
inst✝¹¹ : AddMonoid C
inst✝¹⁰ : DistribMulAction M C
R : Type ?u.120850
inst✝⁹ : Semiring R
inst✝⁸ : MulSemiringAction M R
R' : Type ?u.120877
inst✝⁷ : Ring R'
inst✝⁶ : MulSemiringAction M R'
S : Type ?u.121073
inst✝⁵ : Semiring S
inst✝⁴ : MulSemiringAction M S
S' : Type ?u.121100
inst✝³ : Ring S'
inst✝² : MulSemiringAction M S'
T : Type ?u.121296
inst✝¹ : Semiring T
inst✝ : MulSemiringAction M T
f g : A →+[M] B
h : ↑f = ↑g
a : A
⊢ ↑f a = ↑g a
Theorem: uniformity_eq_comap_inv_mul_nhds_one_swapped
File: Mathlib/Topology/Algebra/UniformGroup.lean

tactic: rw [← comap_swap_uniformity, uniformity_eq_comap_inv_mul_nhds_one, comap_comap]
state_before: α : Type u_1
β : Type ?u.171854
inst✝² : UniformSpace α
inst✝¹ : Group α
inst✝ : UniformGroup α
⊢ 𝓤 α = comap (fun x => x.snd⁻¹ * x.fst) (𝓝 1)

tactic: rfl
state_before: α : Type u_1
β : Type ?u.171854
inst✝² : UniformSpace α
inst✝¹ : Group α
inst✝ : UniformGroup α
⊢ comap ((fun x => x.fst⁻¹ * x.snd) ∘ Prod.swap) (𝓝 1) = comap (fun x => x.snd⁻¹ * x.fst) (𝓝 1)
Theorem: ContinuousLinearMap.map_smulₛₗ₂
File: Mathlib/Analysis/NormedSpace/BoundedLinearMaps.lean

tactic: rw [f.map_smulₛₗ, smul_apply]
state_before: 𝕜 : Type u_6
inst✝¹⁶ : NontriviallyNormedField 𝕜
E : Type ?u.164734
inst✝¹⁵ : NormedAddCommGroup E
inst✝¹⁴ : NormedSpace 𝕜 E
F : Type u_5
inst✝¹³ : NormedAddCommGroup F
inst✝¹² : NormedSpace 𝕜 F
G : Type ?u.164919
inst✝¹¹ : NormedAddCommGroup G
inst✝¹⁰ : NormedSpace 𝕜 G
R : Type u_1
𝕜₂ : Type u_7
𝕜' : Type u_2
inst✝⁹ : NontriviallyNormedField 𝕜'
inst✝⁸ : NontriviallyNormedField 𝕜₂
M : Type u_3
inst✝⁷ : TopologicalSpace M
σ₁₂ : 𝕜 →+* 𝕜₂
G' : Type u_4
inst✝⁶ : NormedAddCommGroup G'
inst✝⁵ : NormedSpace 𝕜₂ G'
inst✝⁴ : NormedSpace 𝕜' G'
inst✝³ : SMulCommClass 𝕜₂ 𝕜' G'
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
ρ₁₂ : R →+* 𝕜'
f : M →SL[ρ₁₂] F →SL[σ₁₂] G'
c : R
x : M
y : F
⊢ ↑(↑f (c • x)) y = ↑ρ₁₂ c • ↑(↑f x) y
Theorem: Finset.exists_le_sum_fiber_of_maps_to_of_nsmul_le_sum
File: Mathlib/Combinatorics/Pigeonhole.lean

tactic: simpa only [sum_fiberwise_of_maps_to hf, sum_const]
state_before: α : Type u
β : Type v
M : Type w
inst✝¹ : DecidableEq β
s : Finset α
t : Finset β
f : α → β
w : α → M
b : M
n : ℕ
inst✝ : LinearOrderedCancelAddCommMonoid M
hf : ∀ (a : α), a ∈ s → f a ∈ t
ht : Finset.Nonempty t
hb : card t • b ≤ ∑ x in s, w x
⊢ ∑ i in t, b ≤ ∑ i in t, ∑ x in filter (fun x => f x = i) s, w x
Theorem: WithBot.lt_coe_iff
File: Mathlib/Order/WithBot.lean

tactic: simp [some_eq_coe, coe_eq_coe, coe_lt_coe]
state_before: α : Type u_1
β : Type ?u.19934
γ : Type ?u.19937
δ : Type ?u.19940
a b✝ : α
inst✝ : LT α
b : α
⊢ Option.some b < ↑b✝ ↔ ∀ (a : WithBot α), Option.some b = a → a < ↑b✝

tactic: simp [none_eq_bot, bot_lt_coe]
state_before: α : Type u_1
β : Type ?u.19934
γ : Type ?u.19937
δ : Type ?u.19940
a b : α
inst✝ : LT α
⊢ none < ↑b ↔ ∀ (a : WithBot α), none = a → a < ↑b