tasksource/leandojo huggingface dataset:
Theorem: connectedComponentIn_mono
File: Mathlib/Topology/Connected.lean

tactic: by_cases hx : x ∈ F
state_before: α : Type u
β : Type v
ι : Type ?u.59761
π : ι → Type ?u.59766
inst✝ : TopologicalSpace α
s t u v : Set α
x : α
F G : Set α
h : F ⊆ G
⊢ connectedComponentIn F x ⊆ connectedComponentIn G x

tactic: rw [connectedComponentIn_eq_image hx, connectedComponentIn_eq_image (h hx), ←
  show ((↑) : G → α) ∘ inclusion h = (↑) from rfl, image_comp]
state_before: case pos
α : Type u
β : Type v
ι : Type ?u.59761
π : ι → Type ?u.59766
inst✝ : TopologicalSpace α
s t u v : Set α
x : α
F G : Set α
h : F ⊆ G
hx : x ∈ F
⊢ connectedComponentIn F x ⊆ connectedComponentIn G x

tactic: exact image_subset _ ((continuous_inclusion h).image_connectedComponent_subset ⟨x, hx⟩)
state_before: case pos
α : Type u
β : Type v
ι : Type ?u.59761
π : ι → Type ?u.59766
inst✝ : TopologicalSpace α
s t u v : Set α
x : α
F G : Set α
h : F ⊆ G
hx : x ∈ F
⊢ Subtype.val '' (inclusion h '' connectedComponent { val := x, property := hx }) ⊆
    Subtype.val '' connectedComponent { val := x, property := (_ : x ∈ G) }

tactic: rw [connectedComponentIn_eq_empty hx]
state_before: case neg
α : Type u
β : Type v
ι : Type ?u.59761
π : ι → Type ?u.59766
inst✝ : TopologicalSpace α
s t u v : Set α
x : α
F G : Set α
h : F ⊆ G
hx : ¬x ∈ F
⊢ connectedComponentIn F x ⊆ connectedComponentIn G x

tactic: exact Set.empty_subset _
state_before: case neg
α : Type u
β : Type v
ι : Type ?u.59761
π : ι → Type ?u.59766
inst✝ : TopologicalSpace α
s t u v : Set α
x : α
F G : Set α
h : F ⊆ G
hx : ¬x ∈ F
⊢ ∅ ⊆ connectedComponentIn G x
Theorem: Padic.rat_dense
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: simpa using hε'l
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
q : ℚ_[p]
ε : ℝ
hε : 0 < ε
ε' : ℚ
hε'l : 0 < ↑ε'
hε'r : ↑ε' < ε
⊢ 0 < ε'

tactic: simpa [Norm.norm] using hr
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
q : ℚ_[p]
ε : ℝ
hε : 0 < ε
ε' : ℚ
hε'l : 0 < ↑ε'
hε'r : ↑ε' < ε
r : ℚ
hr : ↑padicNormE (q - ↑r) < ε'
⊢ ‖q - ↑r‖ < ↑ε'
Theorem: continuous_pi_iff
File: Mathlib/Topology/Constructions.lean

tactic: simp only [continuous_iInf_rng, continuous_induced_rng, comp]
state_before: α : Type u
β : Type v
γ : Type ?u.193723
δ : Type ?u.193726
ε : Type ?u.193729
ζ : Type ?u.193732
ι : Type u_1
π : ι → Type u_2
κ : Type ?u.193743
inst✝¹ : TopologicalSpace α
inst✝ : (i : ι) → TopologicalSpace (π i)
f : α → (i : ι) → π i
⊢ Continuous f ↔ ∀ (i : ι), Continuous fun a => f a i
Theorem: div_le_one_of_neg
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [div_le_iff_of_neg hb, one_mul]
state_before: ι : Type ?u.154616
α : Type u_1
β : Type ?u.154622
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
hb : b < 0
⊢ a / b ≤ 1 ↔ b ≤ a
Theorem: dot_self_cross
File: Mathlib/LinearAlgebra/CrossProduct.lean

tactic: rw [cross_apply, vec3_dotProduct]
state_before: R : Type u_1
inst✝ : CommRing R
v w : Fin 3 → R
⊢ v ⬝ᵥ ↑(↑crossProduct v) w = 0

tactic: norm_num
state_before: R : Type u_1
inst✝ : CommRing R
v w : Fin 3 → R
⊢ v 0 * vecCons (v 1 * w 2 - v 2 * w 1) ![v 2 * w 0 - v 0 * w 2, v 0 * w 1 - v 1 * w 0] 0 +
        v 1 * vecCons (v 1 * w 2 - v 2 * w 1) ![v 2 * w 0 - v 0 * w 2, v 0 * w 1 - v 1 * w 0] 1 +
      v 2 * vecCons (v 1 * w 2 - v 2 * w 1) ![v 2 * w 0 - v 0 * w 2, v 0 * w 1 - v 1 * w 0] 2 =
    0

tactic: ring
state_before: R : Type u_1
inst✝ : CommRing R
v w : Fin 3 → R
⊢ v 0 * (v 1 * w 2 - v 2 * w 1) + v 1 * (v 2 * w 0 - v 0 * w 2) + v 2 * (v 0 * w 1 - v 1 * w 0) = 0
Theorem: multiplicity.unique
File: Mathlib/RingTheory/Multiplicity.lean

tactic: have : Finite a b := ⟨k, hsucc⟩
state_before: α : Type u_1
inst✝¹ : Monoid α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
k : ℕ
hk : a ^ k ∣ b
hsucc : ¬a ^ (k + 1) ∣ b
⊢ multiplicity a b ≤ ↑k

tactic: rw [PartENat.le_coe_iff]
state_before: α : Type u_1
inst✝¹ : Monoid α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
k : ℕ
hk : a ^ k ∣ b
hsucc : ¬a ^ (k + 1) ∣ b
this : Finite a b
⊢ multiplicity a b ≤ ↑k

tactic: exact ⟨this, Nat.find_min' _ hsucc⟩
state_before: α : Type u_1
inst✝¹ : Monoid α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
k : ℕ
hk : a ^ k ∣ b
hsucc : ¬a ^ (k + 1) ∣ b
this : Finite a b
⊢ ∃ h, Part.get (multiplicity a b) h ≤ k
Theorem: OnePoint.compl_image_coe
File: Mathlib/Topology/Compactification/OnePoint.lean

tactic: rw [coe_injective.compl_image_eq, compl_range_coe]
state_before: X : Type u_1
s : Set X
⊢ (some '' s)ᶜ = some '' sᶜ ∪ {∞}
Theorem: ENNReal.openEmbedding_coe
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: rw [range_coe']
state_before: α : Type ?u.22659
β : Type ?u.22662
γ : Type ?u.22665
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
⊢ IsOpen (range some)

tactic: exact isOpen_Iio
state_before: α : Type ?u.22659
β : Type ?u.22662
γ : Type ?u.22665
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
⊢ IsOpen (Iio ⊤)
Theorem: Rat.toNNRat_div
File: Mathlib/Data/Rat/NNRat.lean

tactic: rw [div_eq_mul_inv, div_eq_mul_inv, ← toNNRat_inv, ← toNNRat_mul hp]
state_before: p q : ℚ
hp : 0 ≤ p
⊢ toNNRat (p / q) = toNNRat p / toNNRat q
Theorem: MvPolynomial.bind₁_bind₁
File: Mathlib/Data/MvPolynomial/Monad.lean

tactic: simp [bind₁, ← comp_aeval]
state_before: σ : Type u_4
τ : Type u_2
R : Type u_3
S : Type ?u.360595
T : Type ?u.360598
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : CommSemiring T
f✝ : σ → MvPolynomial τ R
υ : Type u_1
f : σ → MvPolynomial τ R
g : τ → MvPolynomial υ R
φ : MvPolynomial σ R
⊢ ↑(bind₁ g) (↑(bind₁ f) φ) = ↑(bind₁ fun i => ↑(bind₁ g) (f i)) φ
Theorem: Finset.singleton_subset_set_iff
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [coe_singleton, Set.singleton_subset_iff]
state_before: α : Type u_1
β : Type ?u.34765
γ : Type ?u.34768
s✝ : Finset α
a✝ b : α
s : Set α
a : α
⊢ ↑{a} ⊆ s ↔ a ∈ s
Theorem: Option.guard_eq_some'
File: Mathlib/Data/Option/Basic.lean

tactic: cases u
state_before: α : Type ?u.16841
β : Type ?u.16844
γ : Type ?u.16847
δ : Type ?u.16850
p : Prop
inst✝ : Decidable p
u : Unit
⊢ _root_.guard p = some u ↔ p

tactic: by_cases h : p <;> simp [_root_.guard, h]
state_before: case unit
α : Type ?u.16841
β : Type ?u.16844
γ : Type ?u.16847
δ : Type ?u.16850
p : Prop
inst✝ : Decidable p
⊢ _root_.guard p = some PUnit.unit ↔ p
Theorem: PolyEquivTensor.invFun_add
File: Mathlib/RingTheory/PolynomialAlgebra.lean

tactic: simp only [invFun, eval₂_add]
state_before: R : Type u_2
A : Type u_1
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
p q : A[X]
⊢ invFun R A (p + q) = invFun R A p + invFun R A q
Theorem: isClosed_setOf_inseparable
File: Mathlib/Topology/Separation.lean

tactic: simp only [← specializes_iff_inseparable, isClosed_setOf_specializes]
state_before: α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : RegularSpace α
a : α
s : Set α
⊢ IsClosed {p | Inseparable p.fst p.snd}
Theorem: nnnorm_norm
File: Mathlib/Analysis/Normed/Field/Basic.lean

tactic: rw [Real.nnnorm_of_nonneg (norm_nonneg a)]
state_before: α : Type u_1
β : Type ?u.382793
γ : Type ?u.382796
ι : Type ?u.382799
inst✝ : SeminormedAddCommGroup α
a : α
⊢ ‖‖a‖‖₊ = ‖a‖₊

tactic: rfl
state_before: α : Type u_1
β : Type ?u.382793
γ : Type ?u.382796
ι : Type ?u.382799
inst✝ : SeminormedAddCommGroup α
a : α
⊢ { val := ‖a‖, property := (_ : 0 ≤ ‖a‖) } = ‖a‖₊
Theorem: Set.empty_pow
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: rw [← tsub_add_cancel_of_le (Nat.succ_le_of_lt <| Nat.pos_of_ne_zero hn), pow_succ, empty_mul]
state_before: F : Type ?u.66863
α : Type u_1
β : Type ?u.66869
γ : Type ?u.66872
inst✝ : Monoid α
s t : Set α
a : α
m n✝ n : ℕ
hn : n ≠ 0
⊢ ∅ ^ n = ∅
Theorem: BilinForm.isAdjointPair_unique_of_nondegenerate
File: Mathlib/LinearAlgebra/BilinearForm.lean

tactic: rw [compLeft_apply, compLeft_apply, hψ₁, hψ₂]
state_before: R : Type ?u.1799446
M : Type ?u.1799449
inst✝¹⁶ : Semiring R
inst✝¹⁵ : AddCommMonoid M
inst✝¹⁴ : Module R M
R₁ : Type u_1
M₁ : Type u_2
inst✝¹³ : Ring R₁
inst✝¹² : AddCommGroup M₁
inst✝¹¹ : Module R₁ M₁
R₂ : Type ?u.1800097
M₂ : Type ?u.1800100
inst✝¹⁰ : CommSemiring R₂
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : Module R₂ M₂
R₃ : Type ?u.1800287
M₃ : Type ?u.1800290
inst✝⁷ : CommRing R₃
inst✝⁶ : AddCommGroup M₃
inst✝⁵ : Module R₃ M₃
V : Type ?u.1800878
K : Type ?u.1800881
inst✝⁴ : Field K
inst✝³ : AddCommGroup V
inst✝² : Module K V
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
M₂' : Type ?u.1802095
inst✝¹ : AddCommMonoid M₂'
inst✝ : Module R₂ M₂'
B : BilinForm R₁ M₁
b : Nondegenerate B
φ ψ₁ ψ₂ : M₁ →ₗ[R₁] M₁
hψ₁ : IsAdjointPair B B ψ₁ φ
hψ₂ : IsAdjointPair B B ψ₂ φ
v w : M₁
⊢ bilin (compLeft B ψ₁) v w = bilin (compLeft B ψ₂) v w
Theorem: essSup_measure_zero
File: Mathlib/MeasureTheory/Function/EssSup.lean

tactic: simp [Set.mem_setOf_eq, EventuallyLE, ae_iff]
state_before: α : Type u_1
β : Type u_2
m✝ : MeasurableSpace α
μ ν : MeasureTheory.Measure α
inst✝ : CompleteLattice β
m : MeasurableSpace α
f : α → β
⊢ ⊥ ∈ {a | ∀ᶠ (n : β) in map f (Measure.ae 0), n ≤ a}
Theorem: List.countp_cons_of_pos
File: Mathlib/Data/List/Count.lean

tactic: have : countp.go p (a :: l) 0 = countp.go p l 1
state_before: α : Type u_1
l✝ : List α
p q : α → Bool
a : α
l : List α
pa : p a = true
⊢ countp p (a :: l) = countp p l + 1

tactic: unfold countp
state_before: α : Type u_1
l✝ : List α
p q : α → Bool
a : α
l : List α
pa : p a = true
this : countp.go p (a :: l) 0 = countp.go p l 1
⊢ countp p (a :: l) = countp p l + 1

tactic: rw [this, add_comm, List.countp_go_eq_add]
state_before: α : Type u_1
l✝ : List α
p q : α → Bool
a : α
l : List α
pa : p a = true
this : countp.go p (a :: l) 0 = countp.go p l 1
⊢ countp.go p (a :: l) 0 = countp.go p l 0 + 1

tactic: change (bif _ then _ else _) = countp.go _ _ _
state_before: case this
α : Type u_1
l✝ : List α
p q : α → Bool
a : α
l : List α
pa : p a = true
⊢ countp.go p (a :: l) 0 = countp.go p l 1

tactic: rw [pa]
state_before: case this
α : Type u_1
l✝ : List α
p q : α → Bool
a : α
l : List α
pa : p a = true
⊢ (bif p a then countp.go p l (0 + 1) else countp.go p l 0) = countp.go p l 1

tactic: rfl
state_before: case this
α : Type u_1
l✝ : List α
p q : α → Bool
a : α
l : List α
pa : p a = true
⊢ (bif true then countp.go p l (0 + 1) else countp.go p l 0) = countp.go p l 1
Theorem: Filter.iInf_neBot_of_directed
File: Mathlib/Order/Filter/Basic.lean

tactic: cases isEmpty_or_nonempty ι
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.110881
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
hn : Nonempty α
hd : Directed (fun x x_1 => x ≥ x_1) f
hb : ∀ (i : ι), NeBot (f i)
⊢ NeBot (iInf f)

tactic: constructor
state_before: case inl
α : Type u
β : Type v
γ : Type w
δ : Type ?u.110881
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
hn : Nonempty α
hd : Directed (fun x x_1 => x ≥ x_1) f
hb : ∀ (i : ι), NeBot (f i)
h✝ : IsEmpty ι
⊢ NeBot (iInf f)

tactic: simp [iInf_of_empty f, top_ne_bot]
state_before: case inl.ne'
α : Type u
β : Type v
γ : Type w
δ : Type ?u.110881
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
hn : Nonempty α
hd : Directed (fun x x_1 => x ≥ x_1) f
hb : ∀ (i : ι), NeBot (f i)
h✝ : IsEmpty ι
⊢ iInf f ≠ ⊥

tactic: exact iInf_neBot_of_directed' hd hb
state_before: case inr
α : Type u
β : Type v
γ : Type w
δ : Type ?u.110881
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
hn : Nonempty α
hd : Directed (fun x x_1 => x ≥ x_1) f
hb : ∀ (i : ι), NeBot (f i)
h✝ : Nonempty ι
⊢ NeBot (iInf f)
Theorem: quotient_norm_sub_rev
File: Mathlib/Analysis/Normed/Group/Quotient.lean

tactic: rw [← neg_sub, quotient_norm_neg]
state_before: M : Type u_1
N : Type ?u.86452
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
x y : M ⧸ S
⊢ ‖x - y‖ = ‖y - x‖
Theorem: Set.ncard_diff_singleton_le
File: Mathlib/Data/Set/Ncard.lean

tactic: obtain hs | hs := s.finite_or_infinite
state_before: α : Type u_1
β : Type ?u.16509
s✝ t : Set α
a✝ b x y : α
f : α → β
s : Set α
a : α
⊢ ncard (s \ {a}) ≤ ncard s

tactic: convert @zero_le ℕ _ _
state_before: case inr
α : Type u_1
β : Type ?u.16509
s✝ t : Set α
a✝ b x y : α
f : α → β
s : Set α
a : α
hs : Set.Infinite s
⊢ ncard (s \ {a}) ≤ ncard s

tactic: exact (hs.diff (by simp : Set.Finite {a})).ncard
state_before: case h.e'_3
α : Type u_1
β : Type ?u.16509
s✝ t : Set α
a✝ b x y : α
f : α → β
s : Set α
a : α
hs : Set.Infinite s
⊢ ncard (s \ {a}) = 0

tactic: apply ncard_le_of_subset (diff_subset _ _) hs
state_before: case inl
α : Type u_1
β : Type ?u.16509
s✝ t : Set α
a✝ b x y : α
f : α → β
s : Set α
a : α
hs : Set.Finite s
⊢ ncard (s \ {a}) ≤ ncard s

tactic: simp
state_before: α : Type u_1
β : Type ?u.16509
s✝ t : Set α
a✝ b x y : α
f : α → β
s : Set α
a : α
hs : Set.Infinite s
⊢ Set.Finite {a}
Theorem: ContinuousLinearMap.ker_closedComplemented_of_finiteDimensional_range
File: Mathlib/Analysis/NormedSpace/Complemented.lean

tactic: set f' : E →L[𝕜] range f := f.codRestrict _ (LinearMap.mem_range_self (f : E →ₗ[𝕜] F))
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.649
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : CompleteSpace 𝕜
f : E →L[𝕜] F
inst✝ : FiniteDimensional 𝕜 { x // x ∈ range f }
⊢ Submodule.ClosedComplemented (ker f)

tactic: rcases f'.exists_right_inverse_of_surjective (f : E →ₗ[𝕜] F).range_rangeRestrict with ⟨g, hg⟩
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.649
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : CompleteSpace 𝕜
f : E →L[𝕜] F
inst✝ : FiniteDimensional 𝕜 { x // x ∈ range f }
f' : E →L[𝕜] { x // x ∈ range f } := codRestrict f (range f) (_ : ∀ (x : E), ↑↑f x ∈ range ↑f)
⊢ Submodule.ClosedComplemented (ker f)

tactic: simpa only [ker_codRestrict] using f'.closedComplemented_ker_of_rightInverse g (ext_iff.1 hg)
state_before: case intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.649
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : CompleteSpace 𝕜
f : E →L[𝕜] F
inst✝ : FiniteDimensional 𝕜 { x // x ∈ range f }
f' : E →L[𝕜] { x // x ∈ range f } := codRestrict f (range f) (_ : ∀ (x : E), ↑↑f x ∈ range ↑f)
g : { x // x ∈ range f } →L[𝕜] E
hg : comp f' g = id 𝕜 { x // x ∈ range f }
⊢ Submodule.ClosedComplemented (ker f)
Theorem: Complex.tan_conj
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [tan, sin_conj, cos_conj, ← map_div₀, tan]
state_before: x y : ℂ
⊢ tan (↑(starRingEnd ℂ) x) = ↑(starRingEnd ℂ) (tan x)
Theorem: LinearMap.disjoint_inl_inr
File: Mathlib/LinearAlgebra/Prod.lean

tactic: simp (config := { contextual := true }) [disjoint_def, @eq_comm M 0, @eq_comm M₂ 0]
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.189055
M₆ : Type ?u.189058
inst✝⁸ : Semiring R
inst✝⁷ : AddCommMonoid M
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : AddCommMonoid M₃
inst✝⁴ : AddCommMonoid M₄
inst✝³ : Module R M
inst✝² : Module R M₂
inst✝¹ : Module R M₃
inst✝ : Module R M₄
⊢ Disjoint (range (inl R M M₂)) (range (inr R M M₂))
Theorem: GroupCat.SurjectiveOfEpiAuxs.τ_symm_apply_fromCoset
File: Mathlib/Algebra/Category/GroupCat/EpiMono.lean

tactic: rw [tau, Equiv.symm_swap, Equiv.swap_apply_left]
state_before: A B : GroupCat
f : A ⟶ B
⊢ ↑τ.symm
      (fromCoset
        { val := (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier,
          property :=
            (_ :
              ∃ y,
                Function.swap leftCoset (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier y =
                  (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier) }) =
    ∞
Theorem: Fin.eq_zero_or_eq_succ
File: Mathlib/Data/Fin/Basic.lean

tactic: rcases i with ⟨_ | j, h⟩
state_before: n✝ m n : ℕ
i : Fin (n + 1)
⊢ i = 0 ∨ ∃ j, i = succ j

tactic: left
state_before: case mk.zero
n✝ m n : ℕ
h : zero < n + 1
⊢ { val := zero, isLt := h } = 0 ∨ ∃ j, { val := zero, isLt := h } = succ j

tactic: rfl
state_before: case mk.zero.h
n✝ m n : ℕ
h : zero < n + 1
⊢ { val := zero, isLt := h } = 0

tactic: right
state_before: case mk.succ
n✝ m n j : ℕ
h : Nat.succ j < n + 1
⊢ { val := Nat.succ j, isLt := h } = 0 ∨ ∃ j_1, { val := Nat.succ j, isLt := h } = succ j_1

tactic: exact ⟨⟨j, Nat.lt_of_succ_lt_succ h⟩, rfl⟩
state_before: case mk.succ.h
n✝ m n j : ℕ
h : Nat.succ j < n + 1
⊢ ∃ j_1, { val := Nat.succ j, isLt := h } = succ j_1
Theorem: tsub_eq_tsub_min
File: Mathlib/Algebra/Order/Sub/Canonical.lean

tactic: cases' le_total a b with h h
state_before: α : Type u_1
inst✝² : CanonicallyLinearOrderedAddMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a✝ b✝ c d a b : α
⊢ a - b = a - min a b

tactic: rw [min_eq_left h, tsub_self, tsub_eq_zero_of_le h]
state_before: case inl
α : Type u_1
inst✝² : CanonicallyLinearOrderedAddMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a✝ b✝ c d a b : α
h : a ≤ b
⊢ a - b = a - min a b

tactic: rw [min_eq_right h]
state_before: case inr
α : Type u_1
inst✝² : CanonicallyLinearOrderedAddMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a✝ b✝ c d a b : α
h : b ≤ a
⊢ a - b = a - min a b
Theorem: CategoryTheory.MonoidalCategory.leftUnitor_tensor'
File: Mathlib/CategoryTheory/Monoidal/CoherenceLemmas.lean

tactic: coherence
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : MonoidalCategory C
X Y : C
⊢ (α_ (𝟙_ C) X Y).hom ≫ (λ_ (X ⊗ Y)).hom = (λ_ X).hom ⊗ 𝟙 Y
Theorem: ContinuousLinearMap.coe_injective
File: Mathlib/Topology/Algebra/Module/Basic.lean

tactic: intro f g H
state_before: R₁ : Type u_3
R₂ : Type u_4
R₃ : Type ?u.257825
inst✝¹⁶ : Semiring R₁
inst✝¹⁵ : Semiring R₂
inst✝¹⁴ : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R₁ →+* R₃
M₁ : Type u_1
inst✝¹³ : TopologicalSpace M₁
inst✝¹² : AddCommMonoid M₁
M'₁ : Type ?u.257912
inst✝¹¹ : TopologicalSpace M'₁
inst✝¹⁰ : AddCommMonoid M'₁
M₂ : Type u_2
inst✝⁹ : TopologicalSpace M₂
inst✝⁸ : AddCommMonoid M₂
M₃ : Type ?u.257930
inst✝⁷ : TopologicalSpace M₃
inst✝⁶ : AddCommMonoid M₃
M₄ : Type ?u.257939
inst✝⁵ : TopologicalSpace M₄
inst✝⁴ : AddCommMonoid M₄
inst✝³ : Module R₁ M₁
inst✝² : Module R₁ M'₁
inst✝¹ : Module R₂ M₂
inst✝ : Module R₃ M₃
⊢ Function.Injective toLinearMap

tactic: cases f
state_before: R₁ : Type u_3
R₂ : Type u_4
R₃ : Type ?u.257825
inst✝¹⁶ : Semiring R₁
inst✝¹⁵ : Semiring R₂
inst✝¹⁴ : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R₁ →+* R₃
M₁ : Type u_1
inst✝¹³ : TopologicalSpace M₁
inst✝¹² : AddCommMonoid M₁
M'₁ : Type ?u.257912
inst✝¹¹ : TopologicalSpace M'₁
inst✝¹⁰ : AddCommMonoid M'₁
M₂ : Type u_2
inst✝⁹ : TopologicalSpace M₂
inst✝⁸ : AddCommMonoid M₂
M₃ : Type ?u.257930
inst✝⁷ : TopologicalSpace M₃
inst✝⁶ : AddCommMonoid M₃
M₄ : Type ?u.257939
inst✝⁵ : TopologicalSpace M₄
inst✝⁴ : AddCommMonoid M₄
inst✝³ : Module R₁ M₁
inst✝² : Module R₁ M'₁
inst✝¹ : Module R₂ M₂
inst✝ : Module R₃ M₃
f g : M₁ →SL[σ₁₂] M₂
H : ↑f = ↑g
⊢ f = g

tactic: cases g
state_before: case mk
R₁ : Type u_3
R₂ : Type u_4
R₃ : Type ?u.257825
inst✝¹⁶ : Semiring R₁
inst✝¹⁵ : Semiring R₂
inst✝¹⁴ : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R₁ →+* R₃
M₁ : Type u_1
inst✝¹³ : TopologicalSpace M₁
inst✝¹² : AddCommMonoid M₁
M'₁ : Type ?u.257912
inst✝¹¹ : TopologicalSpace M'₁
inst✝¹⁰ : AddCommMonoid M'₁
M₂ : Type u_2
inst✝⁹ : TopologicalSpace M₂
inst✝⁸ : AddCommMonoid M₂
M₃ : Type ?u.257930
inst✝⁷ : TopologicalSpace M₃
inst✝⁶ : AddCommMonoid M₃
M₄ : Type ?u.257939
inst✝⁵ : TopologicalSpace M₄
inst✝⁴ : AddCommMonoid M₄
inst✝³ : Module R₁ M₁
inst✝² : Module R₁ M'₁
inst✝¹ : Module R₂ M₂
inst✝ : Module R₃ M₃
g : M₁ →SL[σ₁₂] M₂
toLinearMap✝ : M₁ →ₛₗ[σ₁₂] M₂
cont✝ : Continuous toLinearMap✝.toFun
H : ↑(mk toLinearMap✝) = ↑g
⊢ mk toLinearMap✝ = g

tactic: congr
state_before: case mk.mk
R₁ : Type u_3
R₂ : Type u_4
R₃ : Type ?u.257825
inst✝¹⁶ : Semiring R₁
inst✝¹⁵ : Semiring R₂
inst✝¹⁴ : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R₁ →+* R₃
M₁ : Type u_1
inst✝¹³ : TopologicalSpace M₁
inst✝¹² : AddCommMonoid M₁
M'₁ : Type ?u.257912
inst✝¹¹ : TopologicalSpace M'₁
inst✝¹⁰ : AddCommMonoid M'₁
M₂ : Type u_2
inst✝⁹ : TopologicalSpace M₂
inst✝⁸ : AddCommMonoid M₂
M₃ : Type ?u.257930
inst✝⁷ : TopologicalSpace M₃
inst✝⁶ : AddCommMonoid M₃
M₄ : Type ?u.257939
inst✝⁵ : TopologicalSpace M₄
inst✝⁴ : AddCommMonoid M₄
inst✝³ : Module R₁ M₁
inst✝² : Module R₁ M'₁
inst✝¹ : Module R₂ M₂
inst✝ : Module R₃ M₃
toLinearMap✝¹ : M₁ →ₛₗ[σ₁₂] M₂
cont✝¹ : Continuous toLinearMap✝¹.toFun
toLinearMap✝ : M₁ →ₛₗ[σ₁₂] M₂
cont✝ : Continuous toLinearMap✝.toFun
H : ↑(mk toLinearMap✝¹) = ↑(mk toLinearMap✝)
⊢ mk toLinearMap✝¹ = mk toLinearMap✝
Theorem: CategoryTheory.Abelian.Functor.exact_of_map_injectiveResolution
File: Mathlib/CategoryTheory/Abelian/RightDerived.lean

tactic: simp
state_before: C : Type u
inst✝⁵ : Category C
D : Type u
inst✝⁴ : Category D
F : C ⥤ D
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝³ : Abelian C
inst✝² : Abelian D
inst✝¹ : Functor.Additive F
P : InjectiveResolution X
inst✝ : PreservesFiniteLimits F
⊢ (Iso.refl (F.obj (HomologicalComplex.X ((CochainComplex.single₀ C).obj X) 0))).hom ≫
      F.map (HomologicalComplex.Hom.f P.ι 0) =
    F.map (HomologicalComplex.Hom.f P.ι 0) ≫ (Iso.refl (F.obj (HomologicalComplex.X P.cocomplex 0))).hom

tactic: rw [Iso.refl_hom, Category.id_comp, Iso.symm_hom, HomologicalComplex.dFrom_eq] <;> congr
state_before: C : Type u
inst✝⁵ : Category C
D : Type u
inst✝⁴ : Category D
F : C ⥤ D
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝³ : Abelian C
inst✝² : Abelian D
inst✝¹ : Functor.Additive F
P : InjectiveResolution X
inst✝ : PreservesFiniteLimits F
⊢ (Iso.refl (F.obj (HomologicalComplex.X P.cocomplex 0))).hom ≫
      HomologicalComplex.dFrom ((mapHomologicalComplex F (ComplexShape.up ℕ)).obj P.cocomplex) 0 =
    F.map (HomologicalComplex.d P.cocomplex 0 1) ≫
      (HomologicalComplex.xNextIso ((mapHomologicalComplex F (ComplexShape.up ℕ)).obj P.cocomplex)
            (_ : 0 + 1 = 0 + 1)).symm.hom
Theorem: Set.biUnion_insert
File: Mathlib/Data/Set/Lattice.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.111642
ι : Sort ?u.111645
ι' : Sort ?u.111648
ι₂ : Sort ?u.111651
κ : ι → Sort ?u.111656
κ₁ : ι → Sort ?u.111661
κ₂ : ι → Sort ?u.111666
κ' : ι' → Sort ?u.111671
a : α
s : Set α
t : α → Set β
⊢ (⋃ (x : α) (_ : x ∈ insert a s), t x) = t a ∪ ⋃ (x : α) (_ : x ∈ s), t x
Theorem: MeasureTheory.UnifIntegrable.sub
File: Mathlib/MeasureTheory/Function/UniformIntegrable.lean

tactic: rw [sub_eq_add_neg]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
f g : ι → α → β
p : ℝ≥0∞
hf : UnifIntegrable f p μ
hg : UnifIntegrable g p μ
hp : 1 ≤ p
hf_meas : ∀ (i : ι), AEStronglyMeasurable (f i) μ
hg_meas : ∀ (i : ι), AEStronglyMeasurable (g i) μ
⊢ UnifIntegrable (f - g) p μ

tactic: exact hf.add hg.neg hp hf_meas fun i => (hg_meas i).neg
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
f g : ι → α → β
p : ℝ≥0∞
hf : UnifIntegrable f p μ
hg : UnifIntegrable g p μ
hp : 1 ≤ p
hf_meas : ∀ (i : ι), AEStronglyMeasurable (f i) μ
hg_meas : ∀ (i : ι), AEStronglyMeasurable (g i) μ
⊢ UnifIntegrable (f + -g) p μ