tasksource/leandojo huggingface dataset:
Theorem: Projectivization.independent_iff_completeLattice_independent
File: Mathlib/LinearAlgebra/ProjectiveSpace/Independence.lean

tactic: refine' ⟨_, fun h => _⟩
state_before: ι : Type u_1
K : Type u_2
V : Type u_3
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : ι → ℙ K V
⊢ Independent f ↔ CompleteLattice.Independent fun i => Projectivization.submodule (f i)

tactic: rintro ⟨f, hf, hi⟩
state_before: case refine'_1
ι : Type u_1
K : Type u_2
V : Type u_3
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : ι → ℙ K V
⊢ Independent f → CompleteLattice.Independent fun i => Projectivization.submodule (f i)

tactic: simp only [submodule_mk]
state_before: case refine'_1.mk
ι : Type u_1
K : Type u_2
V : Type u_3
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : ι → V
hf : ∀ (i : ι), f i ≠ 0
hi : LinearIndependent K f
⊢ CompleteLattice.Independent fun i => Projectivization.submodule ((fun i => mk K (f i) (_ : f i ≠ 0)) i)

tactic: exact (CompleteLattice.independent_iff_linearIndependent_of_ne_zero (R := K) hf).mpr hi
state_before: case refine'_1.mk
ι : Type u_1
K : Type u_2
V : Type u_3
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : ι → V
hf : ∀ (i : ι), f i ≠ 0
hi : LinearIndependent K f
⊢ CompleteLattice.Independent fun i => Submodule.span K {f i}

tactic: rw [independent_iff]
state_before: case refine'_2
ι : Type u_1
K : Type u_2
V : Type u_3
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : ι → ℙ K V
h : CompleteLattice.Independent fun i => Projectivization.submodule (f i)
⊢ Independent f

tactic: refine' h.linearIndependent (Projectivization.submodule ∘ f) (fun i => _) fun i => _
state_before: case refine'_2
ι : Type u_1
K : Type u_2
V : Type u_3
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : ι → ℙ K V
h : CompleteLattice.Independent fun i => Projectivization.submodule (f i)
⊢ LinearIndependent K (Projectivization.rep ∘ f)

tactic: simpa only [Function.comp_apply, submodule_eq] using Submodule.mem_span_singleton_self _
state_before: case refine'_2.refine'_1
ι : Type u_1
K : Type u_2
V : Type u_3
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : ι → ℙ K V
h : CompleteLattice.Independent fun i => Projectivization.submodule (f i)
i : ι
⊢ (Projectivization.rep ∘ f) i ∈ (Projectivization.submodule ∘ f) i

tactic: exact rep_nonzero (f i)
state_before: case refine'_2.refine'_2
ι : Type u_1
K : Type u_2
V : Type u_3
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : ι → ℙ K V
h : CompleteLattice.Independent fun i => Projectivization.submodule (f i)
i : ι
⊢ (Projectivization.rep ∘ f) i ≠ 0
Theorem: Metric.tendstoUniformlyOnFilter_iff
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: refine' ⟨fun H ε hε => H _ (dist_mem_uniformity hε), fun H u hu => _⟩
state_before: α : Type u
β : Type v
X : Type ?u.79122
ι✝ : Type ?u.79125
inst✝ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
ι : Type u_1
F : ι → β → α
f : β → α
p : Filter ι
p' : Filter β
⊢ TendstoUniformlyOnFilter F f p p' ↔ ∀ (ε : ℝ), ε > 0 → ∀ᶠ (n : ι × β) in p ×ˢ p', dist (f n.snd) (F n.fst n.snd) < ε

tactic: rcases mem_uniformity_dist.1 hu with ⟨ε, εpos, hε⟩
state_before: α : Type u
β : Type v
X : Type ?u.79122
ι✝ : Type ?u.79125
inst✝ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
ι : Type u_1
F : ι → β → α
f : β → α
p : Filter ι
p' : Filter β
H : ∀ (ε : ℝ), ε > 0 → ∀ᶠ (n : ι × β) in p ×ˢ p', dist (f n.snd) (F n.fst n.snd) < ε
u : Set (α × α)
hu : u ∈ 𝓤 α
⊢ ∀ᶠ (n : ι × β) in p ×ˢ p', (f n.snd, F n.fst n.snd) ∈ u

tactic: refine' (H ε εpos).mono fun n hn => hε hn
state_before: case intro.intro
α : Type u
β : Type v
X : Type ?u.79122
ι✝ : Type ?u.79125
inst✝ : PseudoMetricSpace α
x y z : α
δ ε✝ ε₁ ε₂ : ℝ
s : Set α
ι : Type u_1
F : ι → β → α
f : β → α
p : Filter ι
p' : Filter β
H : ∀ (ε : ℝ), ε > 0 → ∀ᶠ (n : ι × β) in p ×ˢ p', dist (f n.snd) (F n.fst n.snd) < ε
u : Set (α × α)
hu : u ∈ 𝓤 α
ε : ℝ
εpos : ε > 0
hε : ∀ {a b : α}, dist a b < ε → (a, b) ∈ u
⊢ ∀ᶠ (n : ι × β) in p ×ˢ p', (f n.snd, F n.fst n.snd) ∈ u
Theorem: polarCoord_source_ae_eq_univ
File: Mathlib/Analysis/SpecialFunctions/PolarCoord.lean

tactic: have A : polarCoord.sourceᶜ ⊆ LinearMap.ker (LinearMap.snd ℝ ℝ ℝ) := by
  intro x hx
  simp only [polarCoord_source, compl_union, mem_inter_iff, mem_compl_iff, mem_setOf_eq, not_lt,
    Classical.not_not] at hx
  exact hx.2
state_before: ⊢ polarCoord.source =ᵐ[volume] univ

tactic: have B : volume (LinearMap.ker (LinearMap.snd ℝ ℝ ℝ) : Set (ℝ × ℝ)) = 0 := by
  apply Measure.add_haar_submodule
  rw [Ne.def, LinearMap.ker_eq_top]
  intro h
  have : (LinearMap.snd ℝ ℝ ℝ) (0, 1) = (0 : ℝ × ℝ →ₗ[ℝ] ℝ) (0, 1) := by rw [h]
  simp at this
state_before: A : polarCoord.sourceᶜ ⊆ ↑(LinearMap.ker (LinearMap.snd ℝ ℝ ℝ))
⊢ polarCoord.source =ᵐ[volume] univ

tactic: simp only [ae_eq_univ]
state_before: A : polarCoord.sourceᶜ ⊆ ↑(LinearMap.ker (LinearMap.snd ℝ ℝ ℝ))
B : ↑↑volume ↑(LinearMap.ker (LinearMap.snd ℝ ℝ ℝ)) = 0
⊢ polarCoord.source =ᵐ[volume] univ

tactic: exact le_antisymm ((measure_mono A).trans (le_of_eq B)) bot_le
state_before: A : polarCoord.sourceᶜ ⊆ ↑(LinearMap.ker (LinearMap.snd ℝ ℝ ℝ))
B : ↑↑volume ↑(LinearMap.ker (LinearMap.snd ℝ ℝ ℝ)) = 0
⊢ ↑↑volume (polarCoord.sourceᶜ) = 0

tactic: intro x hx
state_before: ⊢ polarCoord.sourceᶜ ⊆ ↑(LinearMap.ker (LinearMap.snd ℝ ℝ ℝ))

tactic: simp only [polarCoord_source, compl_union, mem_inter_iff, mem_compl_iff, mem_setOf_eq, not_lt,
  Classical.not_not] at hx
state_before: x : ℝ × ℝ
hx : x ∈ polarCoord.sourceᶜ
⊢ x ∈ ↑(LinearMap.ker (LinearMap.snd ℝ ℝ ℝ))

tactic: exact hx.2
state_before: x : ℝ × ℝ
hx : x.fst ≤ 0 ∧ x.snd = 0
⊢ x ∈ ↑(LinearMap.ker (LinearMap.snd ℝ ℝ ℝ))

tactic: apply Measure.add_haar_submodule
state_before: A : polarCoord.sourceᶜ ⊆ ↑(LinearMap.ker (LinearMap.snd ℝ ℝ ℝ))
⊢ ↑↑volume ↑(LinearMap.ker (LinearMap.snd ℝ ℝ ℝ)) = 0

tactic: rw [Ne.def, LinearMap.ker_eq_top]
state_before: case hs
A : polarCoord.sourceᶜ ⊆ ↑(LinearMap.ker (LinearMap.snd ℝ ℝ ℝ))
⊢ LinearMap.ker (LinearMap.snd ℝ ℝ ℝ) ≠ ⊤

tactic: intro h
state_before: case hs
A : polarCoord.sourceᶜ ⊆ ↑(LinearMap.ker (LinearMap.snd ℝ ℝ ℝ))
⊢ ¬LinearMap.snd ℝ ℝ ℝ = 0

tactic: have : (LinearMap.snd ℝ ℝ ℝ) (0, 1) = (0 : ℝ × ℝ →ₗ[ℝ] ℝ) (0, 1) := by rw [h]
state_before: case hs
A : polarCoord.sourceᶜ ⊆ ↑(LinearMap.ker (LinearMap.snd ℝ ℝ ℝ))
h : LinearMap.snd ℝ ℝ ℝ = 0
⊢ False

tactic: simp at this
state_before: case hs
A : polarCoord.sourceᶜ ⊆ ↑(LinearMap.ker (LinearMap.snd ℝ ℝ ℝ))
h : LinearMap.snd ℝ ℝ ℝ = 0
this : ↑(LinearMap.snd ℝ ℝ ℝ) (0, 1) = ↑0 (0, 1)
⊢ False

tactic: rw [h]
state_before: A : polarCoord.sourceᶜ ⊆ ↑(LinearMap.ker (LinearMap.snd ℝ ℝ ℝ))
h : LinearMap.snd ℝ ℝ ℝ = 0
⊢ ↑(LinearMap.snd ℝ ℝ ℝ) (0, 1) = ↑0 (0, 1)
Theorem: mul_inv_eq_iff_eq_mul
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [← h, inv_mul_cancel_right]
state_before: α : Type ?u.55077
β : Type ?u.55080
G : Type u_1
inst✝ : Group G
a b c d : G
h : a * b⁻¹ = c
⊢ a = c * b

tactic: rw [h, mul_inv_cancel_right]
state_before: α : Type ?u.55077
β : Type ?u.55080
G : Type u_1
inst✝ : Group G
a b c d : G
h : a = c * b
⊢ a * b⁻¹ = c
Theorem: Equiv.Perm.IsCycleOn.subtypePerm
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: obtain hs | hs := s.subsingleton_or_nontrivial
state_before: ι : Type ?u.1656340
α : Type u_1
β : Type ?u.1656346
f g : Perm α
s t : Set α
a b x y : α
hf : IsCycleOn f s
⊢ IsCycleOn (subtypePerm f (_ : ∀ (x : α), x ∈ s ↔ ↑f x ∈ s)) _root_.Set.univ

tactic: convert (hf.isCycle_subtypePerm hs).isCycleOn
state_before: case inr
ι : Type ?u.1656340
α : Type u_1
β : Type ?u.1656346
f g : Perm α
s t : Set α
a b x y : α
hf : IsCycleOn f s
hs : Set.Nontrivial s
⊢ IsCycleOn (subtypePerm f (_ : ∀ (x : α), x ∈ s ↔ ↑f x ∈ s)) _root_.Set.univ

tactic: rw [eq_comm, Set.eq_univ_iff_forall]
state_before: case h.e'_3
ι : Type ?u.1656340
α : Type u_1
β : Type ?u.1656346
f g : Perm α
s t : Set α
a b x y : α
hf : IsCycleOn f s
hs : Set.Nontrivial s
⊢ _root_.Set.univ = {x | ↑(subtypePerm f (_ : ∀ (x : α), x ∈ s ↔ ↑f x ∈ s)) x ≠ x}

tactic: exact fun x => ne_of_apply_ne ((↑) : s → α) (hf.apply_ne hs x.2)
state_before: case h.e'_3
ι : Type ?u.1656340
α : Type u_1
β : Type ?u.1656346
f g : Perm α
s t : Set α
a b x y : α
hf : IsCycleOn f s
hs : Set.Nontrivial s
⊢ ∀ (x : { x // x ∈ s }), x ∈ {x | ↑(subtypePerm f (_ : ∀ (x : α), x ∈ s ↔ ↑f x ∈ s)) x ≠ x}

tactic: haveI := hs.coe_sort
state_before: case inl
ι : Type ?u.1656340
α : Type u_1
β : Type ?u.1656346
f g : Perm α
s t : Set α
a b x y : α
hf : IsCycleOn f s
hs : Set.Subsingleton s
⊢ IsCycleOn (subtypePerm f (_ : ∀ (x : α), x ∈ s ↔ ↑f x ∈ s)) _root_.Set.univ

tactic: exact isCycleOn_of_subsingleton _ _
state_before: case inl
ι : Type ?u.1656340
α : Type u_1
β : Type ?u.1656346
f g : Perm α
s t : Set α
a b x y : α
hf : IsCycleOn f s
hs : Set.Subsingleton s
this : Subsingleton ↑s
⊢ IsCycleOn (subtypePerm f (_ : ∀ (x : α), x ∈ s ↔ ↑f x ∈ s)) _root_.Set.univ
Theorem: Finset.coe_biUnion
File: Mathlib/Data/Finset/Basic.lean

tactic: simp [Set.ext_iff, mem_biUnion, Set.mem_iUnion, iff_self_iff, mem_coe, imp_true_iff]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.498743
inst✝ : DecidableEq β
s s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
⊢ ↑(Finset.biUnion s t) = ⋃ (x : α) (_ : x ∈ ↑s), ↑(t x)
Theorem: LocalHomeomorph.map_extend_nhdsWithin
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

tactic: rw [map_extend_nhdsWithin_eq_image f I hy, nhdsWithin_inter, ←
  nhdsWithin_extend_target_eq _ _ hy, ← nhdsWithin_inter, (f.extend I).image_source_inter_eq',
  inter_comm]
state_before: 𝕜 : Type u_4
E : Type u_3
M : Type u_1
H : Type u_2
E' : Type ?u.153300
M' : Type ?u.153303
H' : Type ?u.153306
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
y : M
hy : y ∈ f.source
⊢ map (↑(extend f I)) (𝓝[s] y) = 𝓝[↑(LocalEquiv.symm (extend f I)) ⁻¹' s ∩ range ↑I] ↑(extend f I) y
Theorem: bernsteinPolynomial.derivative_succ
File: Mathlib/RingTheory/Polynomial/Bernstein.lean

tactic: cases n
state_before: R : Type u_1
inst✝ : CommRing R
n ν : ℕ
⊢ ↑Polynomial.derivative (bernsteinPolynomial R n (ν + 1)) =
    ↑n * (bernsteinPolynomial R (n - 1) ν - bernsteinPolynomial R (n - 1) (ν + 1))

tactic: simp [bernsteinPolynomial]
state_before: case zero
R : Type u_1
inst✝ : CommRing R
ν : ℕ
⊢ ↑Polynomial.derivative (bernsteinPolynomial R Nat.zero (ν + 1)) =
    ↑Nat.zero * (bernsteinPolynomial R (Nat.zero - 1) ν - bernsteinPolynomial R (Nat.zero - 1) (ν + 1))

tactic: rw [Nat.cast_succ]
state_before: case succ
R : Type u_1
inst✝ : CommRing R
ν n✝ : ℕ
⊢ ↑Polynomial.derivative (bernsteinPolynomial R (Nat.succ n✝) (ν + 1)) =
    ↑(Nat.succ n✝) * (bernsteinPolynomial R (Nat.succ n✝ - 1) ν - bernsteinPolynomial R (Nat.succ n✝ - 1) (ν + 1))

tactic: apply derivative_succ_aux
state_before: case succ
R : Type u_1
inst✝ : CommRing R
ν n✝ : ℕ
⊢ ↑Polynomial.derivative (bernsteinPolynomial R (Nat.succ n✝) (ν + 1)) =
    (↑n✝ + 1) * (bernsteinPolynomial R (Nat.succ n✝ - 1) ν - bernsteinPolynomial R (Nat.succ n✝ - 1) (ν + 1))
Theorem: List.join_splitWrtCompositionAux
File: Mathlib/Combinatorics/Composition.lean

tactic: induction' ns with n ns IH <;> intro l h <;> simp at h
state_before: n : ℕ
α : Type u_1
ns : List ℕ
⊢ ∀ {l : List α}, sum ns = length l → join (splitWrtCompositionAux l ns) = l

tactic: simp only [splitWrtCompositionAux_cons]
state_before: case cons
n✝ : ℕ
α : Type u_1
n : ℕ
ns : List ℕ
IH : ∀ {l : List α}, sum ns = length l → join (splitWrtCompositionAux l ns) = l
l : List α
h : n + sum ns = length l
⊢ join (splitWrtCompositionAux l (n :: ns)) = l

tactic: dsimp
state_before: case cons
n✝ : ℕ
α : Type u_1
n : ℕ
ns : List ℕ
IH : ∀ {l : List α}, sum ns = length l → join (splitWrtCompositionAux l ns) = l
l : List α
h : n + sum ns = length l
⊢ join (take n l :: splitWrtCompositionAux (drop n l) ns) = l

tactic: rw [IH]
state_before: case cons
n✝ : ℕ
α : Type u_1
n : ℕ
ns : List ℕ
IH : ∀ {l : List α}, sum ns = length l → join (splitWrtCompositionAux l ns) = l
l : List α
h : n + sum ns = length l
⊢ take n l ++ join (splitWrtCompositionAux (drop n l) ns) = l

tactic: . rw [length_drop, ← h, add_tsub_cancel_left]
state_before: case cons
n✝ : ℕ
α : Type u_1
n : ℕ
ns : List ℕ
IH : ∀ {l : List α}, sum ns = length l → join (splitWrtCompositionAux l ns) = l
l : List α
h : n + sum ns = length l
⊢ sum ns = length (drop n l)

tactic: exact (length_eq_zero.1 h.symm).symm
state_before: case nil
n : ℕ
α : Type u_1
l : List α
h : 0 = length l
⊢ join (splitWrtCompositionAux l []) = l

tactic: simp
state_before: case cons
n✝ : ℕ
α : Type u_1
n : ℕ
ns : List ℕ
IH : ∀ {l : List α}, sum ns = length l → join (splitWrtCompositionAux l ns) = l
l : List α
h : n + sum ns = length l
⊢ take n l ++ drop n l = l

tactic: rw [length_drop, ← h, add_tsub_cancel_left]
state_before: case cons
n✝ : ℕ
α : Type u_1
n : ℕ
ns : List ℕ
IH : ∀ {l : List α}, sum ns = length l → join (splitWrtCompositionAux l ns) = l
l : List α
h : n + sum ns = length l
⊢ sum ns = length (drop n l)
Theorem: Computation.LiftRelAux.ret_left
File: Mathlib/Data/Seq/Computation.lean

tactic: apply cb.recOn (fun b => _) fun cb => _
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
C : Computation α → Computation β → Prop
a : α
cb : Computation β
⊢ LiftRelAux R C (Sum.inl a) (destruct cb) ↔ ∃ b, b ∈ cb ∧ R a b

tactic: intro b
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
C : Computation α → Computation β → Prop
a : α
cb : Computation β
⊢ ∀ (b : β), LiftRelAux R C (Sum.inl a) (destruct (pure b)) ↔ ∃ b_1, b_1 ∈ pure b ∧ R a b_1

tactic: exact
  ⟨fun h => ⟨_, ret_mem _, h⟩, fun ⟨b', mb, h⟩ => by rw [mem_unique (ret_mem _) mb] ; exact h⟩
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
C : Computation α → Computation β → Prop
a : α
cb : Computation β
b : β
⊢ LiftRelAux R C (Sum.inl a) (destruct (pure b)) ↔ ∃ b_1, b_1 ∈ pure b ∧ R a b_1

tactic: rw [mem_unique (ret_mem _) mb]
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
C : Computation α → Computation β → Prop
a : α
cb : Computation β
b : β
x✝ : ∃ b_1, b_1 ∈ pure b ∧ R a b_1
b' : β
mb : b' ∈ pure b
h : R a b'
⊢ LiftRelAux R C (Sum.inl a) (destruct (pure b))

tactic: exact h
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
C : Computation α → Computation β → Prop
a : α
cb : Computation β
b : β
x✝ : ∃ b_1, b_1 ∈ pure b ∧ R a b_1
b' : β
mb : b' ∈ pure b
h : R a b'
⊢ LiftRelAux R C (Sum.inl a) (destruct (pure b'))

tactic: intro
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
C : Computation α → Computation β → Prop
a : α
cb : Computation β
⊢ ∀ (cb : Computation β), LiftRelAux R C (Sum.inl a) (destruct (think cb)) ↔ ∃ b, b ∈ think cb ∧ R a b

tactic: rw [destruct_think]
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
C : Computation α → Computation β → Prop
a : α
cb cb✝ : Computation β
⊢ LiftRelAux R C (Sum.inl a) (destruct (think cb✝)) ↔ ∃ b, b ∈ think cb✝ ∧ R a b

tactic: exact ⟨fun ⟨b, h, r⟩ => ⟨b, think_mem h, r⟩, fun ⟨b, h, r⟩ => ⟨b, of_think_mem h, r⟩⟩
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
C : Computation α → Computation β → Prop
a : α
cb cb✝ : Computation β
⊢ LiftRelAux R C (Sum.inl a) (Sum.inr cb✝) ↔ ∃ b, b ∈ think cb✝ ∧ R a b
Theorem: Nat.factorization_le_factorization_mul_left
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: rcases eq_or_ne a 0 with (rfl | ha)
state_before: a b : ℕ
hb : b ≠ 0
⊢ factorization a ≤ factorization (a * b)

tactic: rw [factorization_le_iff_dvd ha <| mul_ne_zero ha hb]
state_before: case inr
a b : ℕ
hb : b ≠ 0
ha : a ≠ 0
⊢ factorization a ≤ factorization (a * b)

tactic: exact Dvd.intro b rfl
state_before: case inr
a b : ℕ
hb : b ≠ 0
ha : a ≠ 0
⊢ a ∣ a * b

tactic: simp
state_before: case inl
b : ℕ
hb : b ≠ 0
⊢ factorization 0 ≤ factorization (0 * b)
Theorem: TopCat.Presheaf.pushforwardEq_rfl
File: Mathlib/Topology/Sheaves/Presheaf.lean

tactic: dsimp [pushforwardEq]
state_before: C : Type u
inst✝ : Category C
X Y : TopCat
f : X ⟶ Y
ℱ : Presheaf C X
U : Opens ↑Y
⊢ (pushforwardEq (_ : f = f) ℱ).hom.app U.op = 𝟙 ((f _* ℱ).obj U.op)

tactic: simp
state_before: C : Type u
inst✝ : Category C
X Y : TopCat
f : X ⟶ Y
ℱ : Presheaf C X
U : Opens ↑Y
⊢ ℱ.map (𝟙 ((Opens.map f).obj U).op) = 𝟙 (ℱ.obj ((Opens.map f).obj U).op)
Theorem: Set.wellFoundedLT_of_chainHeight_ne_top
File: Mathlib/Order/Height.lean

tactic: rwa [chainHeight_dual]
state_before: α : Type u_1
β : Type ?u.52761
s✝ t : Set α
inst✝ : Preorder α
s : Set α
hs : chainHeight s ≠ ⊤
⊢ chainHeight (↑ofDual ⁻¹' s) ≠ ⊤
Theorem: AddCommGroup.not_modEq_iff_toIcoDiv_eq_toIocDiv
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [not_modEq_iff_toIcoMod_eq_toIocMod hp, toIcoMod, toIocMod, sub_right_inj,
  (zsmul_strictMono_left hp).injective.eq_iff]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
⊢ ¬a ≡ b [PMOD p] ↔ toIcoDiv hp a b = toIocDiv hp a b
Theorem: MeasureTheory.Measure.Regular.smul
File: Mathlib/MeasureTheory/Measure/Regular.lean

tactic: haveI := OuterRegular.smul μ hx
state_before: α : Type u_1
β : Type ?u.71015
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace α
μ : Measure α
inst✝ : Regular μ
x : ℝ≥0∞
hx : x ≠ ⊤
⊢ Regular (x • μ)

tactic: haveI := IsFiniteMeasureOnCompacts.smul μ hx
state_before: α : Type u_1
β : Type ?u.71015
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace α
μ : Measure α
inst✝ : Regular μ
x : ℝ≥0∞
hx : x ≠ ⊤
this : OuterRegular (x • μ)
⊢ Regular (x • μ)

tactic: exact ⟨Regular.innerRegular.smul x⟩
state_before: α : Type u_1
β : Type ?u.71015
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace α
μ : Measure α
inst✝ : Regular μ
x : ℝ≥0∞
hx : x ≠ ⊤
this✝ : OuterRegular (x • μ)
this : IsFiniteMeasureOnCompacts (x • μ)
⊢ Regular (x • μ)
Theorem: Set.strictAntiOn_iff_strictAnti
File: Mathlib/Data/Set/Basic.lean

tactic: simp [StrictAnti, StrictAntiOn]
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 : α → β
⊢ StrictAntiOn f s ↔ StrictAnti fun a => f ↑a
Theorem: CategoryTheory.Limits.biproduct.conePointUniqueUpToIso_inv
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

tactic: refine' biproduct.hom_ext' _ _ fun j => hb.isLimit.hom_ext fun j' => _
state_before: J : Type w
C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
f : J → C
inst✝ : HasBiproduct f
b : Bicone f
hb : Bicone.IsBilimit b
⊢ (IsLimit.conePointUniqueUpToIso hb.isLimit (isLimit f)).inv = desc b.ι

tactic: rw [Category.assoc, IsLimit.conePointUniqueUpToIso_inv_comp, Bicone.toCone_π_app,
  biproduct.bicone_π, biproduct.ι_desc, biproduct.ι_π, b.toCone_π_app, b.ι_π]
state_before: J : Type w
C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
f : J → C
inst✝ : HasBiproduct f
b : Bicone f
hb : Bicone.IsBilimit b
j : J
j' : Discrete J
⊢ (ι f j ≫ (IsLimit.conePointUniqueUpToIso hb.isLimit (isLimit f)).inv) ≫ (Bicone.toCone b).π.app j' =
    (ι f j ≫ desc b.ι) ≫ (Bicone.toCone b).π.app j'
Theorem: ProbabilityTheory.condCount_inter
File: Mathlib/Probability/CondCount.lean

tactic: by_cases hst : s ∩ t = ∅
state_before: Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t u : Set Ω
hs : Set.Finite s
⊢ ↑↑(condCount s) (t ∩ u) = ↑↑(condCount (s ∩ t)) u * ↑↑(condCount s) t

tactic: rw [condCount, condCount, cond_apply _ hs.measurableSet, cond_apply _ hs.measurableSet,
  cond_apply _ (hs.inter_of_left _).measurableSet, mul_comm _ (Measure.count (s ∩ t)),
  ← mul_assoc, mul_comm _ (Measure.count (s ∩ t)), ← mul_assoc, ENNReal.mul_inv_cancel, one_mul,
  mul_comm, Set.inter_assoc]
state_before: case neg
Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t u : Set Ω
hs : Set.Finite s
hst : ¬s ∩ t = ∅
⊢ ↑↑(condCount s) (t ∩ u) = ↑↑(condCount (s ∩ t)) u * ↑↑(condCount s) t

tactic: rw [hst, condCount_empty_meas, Measure.coe_zero, Pi.zero_apply, MulZeroClass.zero_mul,
  condCount_eq_zero_iff hs, ← Set.inter_assoc, hst, Set.empty_inter]
state_before: case pos
Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t u : Set Ω
hs : Set.Finite s
hst : s ∩ t = ∅
⊢ ↑↑(condCount s) (t ∩ u) = ↑↑(condCount (s ∩ t)) u * ↑↑(condCount s) t

tactic: rwa [← Measure.count_eq_zero_iff] at hst
state_before: case neg.h0
Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t u : Set Ω
hs : Set.Finite s
hst : ¬s ∩ t = ∅
⊢ ↑↑Measure.count (s ∩ t) ≠ 0

tactic: exact (Measure.count_apply_lt_top.2 <| hs.inter_of_left _).ne
state_before: case neg.ht
Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t u : Set Ω
hs : Set.Finite s
hst : ¬s ∩ t = ∅
⊢ ↑↑Measure.count (s ∩ t) ≠ ⊤
Theorem: SimpleGraph.Walk.support_transfer
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p <;> simp [*]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H : SimpleGraph V
hp : ∀ (e : Sym2 V), e ∈ edges p → e ∈ edgeSet H
⊢ support (Walk.transfer p H hp) = support p
Theorem: Module.End.ker_pow_le_ker_pow_finrank
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: by_cases h_cases : m < finrank K V
state_before: K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
m : ℕ
⊢ LinearMap.ker (f ^ m) ≤ LinearMap.ker (f ^ finrank K V)

tactic: rw [← add_tsub_cancel_of_le (Nat.le_of_lt h_cases), add_comm, pow_add]
state_before: case pos
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
m : ℕ
h_cases : m < finrank K V
⊢ LinearMap.ker (f ^ m) ≤ LinearMap.ker (f ^ finrank K V)

tactic: apply LinearMap.ker_le_ker_comp
state_before: case pos
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
m : ℕ
h_cases : m < finrank K V
⊢ LinearMap.ker (f ^ m) ≤ LinearMap.ker (f ^ (finrank K V - m) * f ^ m)

tactic: rw [ker_pow_eq_ker_pow_finrank_of_le (le_of_not_lt h_cases)]
state_before: case neg
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
m : ℕ
h_cases : ¬m < finrank K V
⊢ LinearMap.ker (f ^ m) ≤ LinearMap.ker (f ^ finrank K V)
Theorem: Metric.continuousAt_inv_infDist_pt
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: rcases s.eq_empty_or_nonempty with (rfl | hs)
state_before: ι : Sort ?u.66671
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
h : ¬x ∈ closure s
⊢ ContinuousAt (fun x => (infDist x s)⁻¹) x

tactic: simp only [infDist_empty, continuousAt_const]
state_before: case inl
ι : Sort ?u.66671
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
t u : Set α
x y : α
Φ : α → β
h : ¬x ∈ closure ∅
⊢ ContinuousAt (fun x => (infDist x ∅)⁻¹) x

tactic: refine (continuous_infDist_pt s).continuousAt.inv₀ ?_
state_before: case inr
ι : Sort ?u.66671
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
h : ¬x ∈ closure s
hs : Set.Nonempty s
⊢ ContinuousAt (fun x => (infDist x s)⁻¹) x

tactic: rwa [Ne.def, ← mem_closure_iff_infDist_zero hs]
state_before: case inr
ι : Sort ?u.66671
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
h : ¬x ∈ closure s
hs : Set.Nonempty s
⊢ infDist x s ≠ 0
Theorem: ENNReal.toNNReal_eq_toNNReal_iff'
File: Mathlib/Data/Real/ENNReal.lean

tactic: simp only [ENNReal.toNNReal_eq_toNNReal_iff x y, hx, hy, and_false, false_and, or_false]
state_before: α : Type ?u.32929
β : Type ?u.32932
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y : ℝ≥0∞
hx : x ≠ ⊤
hy : y ≠ ⊤
⊢ ENNReal.toNNReal x = ENNReal.toNNReal y ↔ x = y