tasksource/leandojo huggingface dataset:
Theorem: chainClosure_succ_total_aux
File: Mathlib/Order/Chain.lean

tactic: induction hc₁
state_before: α : Type u_1
β : Type ?u.11219
r : α → α → Prop
c c₁ c₂ c₃ s t : Set α
a b x y : α
hc₁ : ChainClosure r c₁
h : ∀ ⦃c₃ : Set α⦄, ChainClosure r c₃ → c₃ ⊆ c₂ → c₂ = c₃ ∨ SuccChain r c₃ ⊆ c₂
⊢ SuccChain r c₂ ⊆ c₁ ∨ c₁ ⊆ c₂

tactic: case union s _ ih =>
  refine' or_iff_not_imp_left.2 fun hn => sUnion_subset fun a ha => _
  exact (ih a ha).resolve_left fun h => hn <| h.trans <| subset_sUnion_of_mem ha
state_before: case union
α : Type u_1
β : Type ?u.11219
r : α → α → Prop
c c₁ c₂ c₃ s t : Set α
a b x y : α
h : ∀ ⦃c₃ : Set α⦄, ChainClosure r c₃ → c₃ ⊆ c₂ → c₂ = c₃ ∨ SuccChain r c₃ ⊆ c₂
s✝ : Set (Set α)
a✝ : ∀ (a : Set α), a ∈ s✝ → ChainClosure r a
a_ih✝ : ∀ (a : Set α), a ∈ s✝ → SuccChain r c₂ ⊆ a ∨ a ⊆ c₂
⊢ SuccChain r c₂ ⊆ ⋃₀ s✝ ∨ ⋃₀ s✝ ⊆ c₂

tactic: cases' ih with ih ih
state_before: α : Type u_1
β : Type ?u.11219
r : α → α → Prop
c c₁ c₂ c₃✝ s t : Set α
a b x y : α
h : ∀ ⦃c₃ : Set α⦄, ChainClosure r c₃ → c₃ ⊆ c₂ → c₂ = c₃ ∨ SuccChain r c₃ ⊆ c₂
c₃ : Set α
hc₃ : ChainClosure r c₃
ih : SuccChain r c₂ ⊆ c₃ ∨ c₃ ⊆ c₂
⊢ SuccChain r c₂ ⊆ SuccChain r c₃ ∨ SuccChain r c₃ ⊆ c₂

tactic: exact Or.inl (ih.trans subset_succChain)
state_before: case inl
α : Type u_1
β : Type ?u.11219
r : α → α → Prop
c c₁ c₂ c₃✝ s t : Set α
a b x y : α
h : ∀ ⦃c₃ : Set α⦄, ChainClosure r c₃ → c₃ ⊆ c₂ → c₂ = c₃ ∨ SuccChain r c₃ ⊆ c₂
c₃ : Set α
hc₃ : ChainClosure r c₃
ih : SuccChain r c₂ ⊆ c₃
⊢ SuccChain r c₂ ⊆ SuccChain r c₃ ∨ SuccChain r c₃ ⊆ c₂

tactic: exact (h hc₃ ih).imp_left fun (h : c₂ = c₃) => h ▸ Subset.rfl
state_before: case inr
α : Type u_1
β : Type ?u.11219
r : α → α → Prop
c c₁ c₂ c₃✝ s t : Set α
a b x y : α
h : ∀ ⦃c₃ : Set α⦄, ChainClosure r c₃ → c₃ ⊆ c₂ → c₂ = c₃ ∨ SuccChain r c₃ ⊆ c₂
c₃ : Set α
hc₃ : ChainClosure r c₃
ih : c₃ ⊆ c₂
⊢ SuccChain r c₂ ⊆ SuccChain r c₃ ∨ SuccChain r c₃ ⊆ c₂

tactic: refine' or_iff_not_imp_left.2 fun hn => sUnion_subset fun a ha => _
state_before: α : Type u_1
β : Type ?u.11219
r : α → α → Prop
c c₁ c₂ c₃ s✝ t : Set α
a b x y : α
h : ∀ ⦃c₃ : Set α⦄, ChainClosure r c₃ → c₃ ⊆ c₂ → c₂ = c₃ ∨ SuccChain r c₃ ⊆ c₂
s : Set (Set α)
a✝ : ∀ (a : Set α), a ∈ s → ChainClosure r a
ih : ∀ (a : Set α), a ∈ s → SuccChain r c₂ ⊆ a ∨ a ⊆ c₂
⊢ SuccChain r c₂ ⊆ ⋃₀ s ∨ ⋃₀ s ⊆ c₂

tactic: exact (ih a ha).resolve_left fun h => hn <| h.trans <| subset_sUnion_of_mem ha
state_before: α : Type u_1
β : Type ?u.11219
r : α → α → Prop
c c₁ c₂ c₃ s✝ t : Set α
a✝¹ b x y : α
h : ∀ ⦃c₃ : Set α⦄, ChainClosure r c₃ → c₃ ⊆ c₂ → c₂ = c₃ ∨ SuccChain r c₃ ⊆ c₂
s : Set (Set α)
a✝ : ∀ (a : Set α), a ∈ s → ChainClosure r a
ih : ∀ (a : Set α), a ∈ s → SuccChain r c₂ ⊆ a ∨ a ⊆ c₂
hn : ¬SuccChain r c₂ ⊆ ⋃₀ s
a : Set α
ha : a ∈ s
⊢ a ⊆ c₂
Theorem: Matrix.transpose_map
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type ?u.929277
m : Type u_1
n : Type u_2
o : Type ?u.929286
m' : o → Type ?u.929291
n' : o → Type ?u.929296
R : Type ?u.929299
S : Type ?u.929302
α : Type v
β : Type w
γ : Type ?u.929309
f : α → β
M : Matrix m n α
⊢ map Mᵀ f = (map M f)ᵀ

tactic: rfl
state_before: case a.h
l : Type ?u.929277
m : Type u_1
n : Type u_2
o : Type ?u.929286
m' : o → Type ?u.929291
n' : o → Type ?u.929296
R : Type ?u.929299
S : Type ?u.929302
α : Type v
β : Type w
γ : Type ?u.929309
f : α → β
M : Matrix m n α
i✝ : n
x✝ : m
⊢ map Mᵀ f i✝ x✝ = (map M f)ᵀ i✝ x✝
Theorem: Nat.ord_compl_dvd_ord_compl_iff_dvd
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: refine' ⟨fun h => _, fun hab p => ord_compl_dvd_ord_compl_of_dvd hab p⟩
state_before: a b : ℕ
⊢ (∀ (p : ℕ), a / p ^ ↑(factorization a) p ∣ b / p ^ ↑(factorization b) p) ↔ a ∣ b

tactic: rcases eq_or_ne b 0 with (rfl | hb0)
state_before: a b : ℕ
h : ∀ (p : ℕ), a / p ^ ↑(factorization a) p ∣ b / p ^ ↑(factorization b) p
⊢ a ∣ b

tactic: by_cases pa : a.Prime
state_before: case inr
a b : ℕ
h : ∀ (p : ℕ), a / p ^ ↑(factorization a) p ∣ b / p ^ ↑(factorization b) p
hb0 : b ≠ 0
⊢ a ∣ b

tactic: case neg => simpa [pa] using h a
state_before: case pos
a b : ℕ
h : ∀ (p : ℕ), a / p ^ ↑(factorization a) p ∣ b / p ^ ↑(factorization b) p
hb0 : b ≠ 0
pa : Prime a
⊢ a ∣ b

case neg
a b : ℕ
h : ∀ (p : ℕ), a / p ^ ↑(factorization a) p ∣ b / p ^ ↑(factorization b) p
hb0 : b ≠ 0
pa : ¬Prime a
⊢ a ∣ b

tactic: by_cases pb : b.Prime
state_before: case pos
a b : ℕ
h : ∀ (p : ℕ), a / p ^ ↑(factorization a) p ∣ b / p ^ ↑(factorization b) p
hb0 : b ≠ 0
pa : Prime a
⊢ a ∣ b

tactic: case neg => simpa [pb] using h b
state_before: case pos
a b : ℕ
h : ∀ (p : ℕ), a / p ^ ↑(factorization a) p ∣ b / p ^ ↑(factorization b) p
hb0 : b ≠ 0
pa : Prime a
pb : Prime b
⊢ a ∣ b

case neg
a b : ℕ
h : ∀ (p : ℕ), a / p ^ ↑(factorization a) p ∣ b / p ^ ↑(factorization b) p
hb0 : b ≠ 0
pa : Prime a
pb : ¬Prime b
⊢ a ∣ b

tactic: rw [prime_dvd_prime_iff_eq pa pb]
state_before: case pos
a b : ℕ
h : ∀ (p : ℕ), a / p ^ ↑(factorization a) p ∣ b / p ^ ↑(factorization b) p
hb0 : b ≠ 0
pa : Prime a
pb : Prime b
⊢ a ∣ b

tactic: by_contra hab
state_before: case pos
a b : ℕ
h : ∀ (p : ℕ), a / p ^ ↑(factorization a) p ∣ b / p ^ ↑(factorization b) p
hb0 : b ≠ 0
pa : Prime a
pb : Prime b
⊢ a = b

tactic: apply pa.ne_one
state_before: case pos
a b : ℕ
h : ∀ (p : ℕ), a / p ^ ↑(factorization a) p ∣ b / p ^ ↑(factorization b) p
hb0 : b ≠ 0
pa : Prime a
pb : Prime b
hab : ¬a = b
⊢ False

tactic: rw [← Nat.dvd_one, ← Nat.mul_dvd_mul_iff_left hb0.bot_lt, mul_one]
state_before: case pos
a b : ℕ
h : ∀ (p : ℕ), a / p ^ ↑(factorization a) p ∣ b / p ^ ↑(factorization b) p
hb0 : b ≠ 0
pa : Prime a
pb : Prime b
hab : ¬a = b
⊢ a = 1

tactic: simpa [Prime.factorization_self pb, Prime.factorization pa, hab] using h b
state_before: case pos
a b : ℕ
h : ∀ (p : ℕ), a / p ^ ↑(factorization a) p ∣ b / p ^ ↑(factorization b) p
hb0 : b ≠ 0
pa : Prime a
pb : Prime b
hab : ¬a = b
⊢ b * a ∣ b

tactic: simp
state_before: case inl
a : ℕ
h : ∀ (p : ℕ), a / p ^ ↑(factorization a) p ∣ 0 / p ^ ↑(factorization 0) p
⊢ a ∣ 0

tactic: simpa [pa] using h a
state_before: a b : ℕ
h : ∀ (p : ℕ), a / p ^ ↑(factorization a) p ∣ b / p ^ ↑(factorization b) p
hb0 : b ≠ 0
pa : ¬Prime a
⊢ a ∣ b

tactic: simpa [pb] using h b
state_before: a b : ℕ
h : ∀ (p : ℕ), a / p ^ ↑(factorization a) p ∣ b / p ^ ↑(factorization b) p
hb0 : b ≠ 0
pa : Prime a
pb : ¬Prime b
⊢ a ∣ b
Theorem: Set.chainHeight_insert_of_forall_lt
File: Mathlib/Order/Height.lean

tactic: rw [← chainHeight_dual, ← chainHeight_dual s]
state_before: α : Type u_1
β : Type ?u.37265
s t : Set α
inst✝ : Preorder α
a : α
ha : ∀ (b : α), b ∈ s → b < a
⊢ chainHeight (insert a s) = chainHeight s + 1

tactic: exact chainHeight_insert_of_forall_gt _ ha
state_before: α : Type u_1
β : Type ?u.37265
s t : Set α
inst✝ : Preorder α
a : α
ha : ∀ (b : α), b ∈ s → b < a
⊢ chainHeight (↑ofDual ⁻¹' insert a s) = chainHeight (↑ofDual ⁻¹' s) + 1
Theorem: MeasureTheory.lintegral_edist_lt_top
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: simp_rw [Pi.zero_apply, ← hasFiniteIntegral_iff_edist]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.936048
δ : Type ?u.936051
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f g : α → β
hf : Integrable f
hg : Integrable g
⊢ (∫⁻ (a : α), edist (f a) (OfNat.ofNat 0 a) ∂μ) < ⊤ ∧ (∫⁻ (a : α), edist (g a) (OfNat.ofNat 0 a) ∂μ) < ⊤

tactic: exact ⟨hf.hasFiniteIntegral, hg.hasFiniteIntegral⟩
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.936048
δ : Type ?u.936051
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f g : α → β
hf : Integrable f
hg : Integrable g
⊢ (HasFiniteIntegral fun a => f a) ∧ HasFiniteIntegral fun a => g a
Theorem: MeasureTheory.snorm'_norm
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: simp [snorm']
state_before: α : Type u_1
E : Type ?u.1595212
F : Type u_2
G : Type ?u.1595218
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
⊢ snorm' (fun a => ‖f a‖) q μ = snorm' f q μ
Theorem: himp_himp
File: Mathlib/Order/Heyting/Basic.lean

tactic: simp_rw [le_himp_iff, inf_assoc]
state_before: ι : Type ?u.30204
α : Type u_1
β : Type ?u.30210
inst✝ : GeneralizedHeytingAlgebra α
a✝ b✝ c✝ d✝ a b c d : α
⊢ d ≤ a ⇨ b ⇨ c ↔ d ≤ a ⊓ b ⇨ c
Theorem: min_eq_half_add_sub_abs_sub
File: Mathlib/Topology/ContinuousFunction/Algebra.lean

tactic: cases' le_total x y with h h <;> field_simp [h, abs_of_nonneg, abs_of_nonpos, mul_two]
state_before: R : Type u_1
inst✝ : LinearOrderedField R
x y : R
⊢ min x y = 2⁻¹ * (x + y - abs (x - y))

tactic: abel
state_before: case inl
R : Type u_1
inst✝ : LinearOrderedField R
x y : R
h : x ≤ y
⊢ x + x = x + y - (y - x)
Theorem: measurable_of_isOpen
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean

tactic: rw [‹BorelSpace γ›.measurable_eq]
state_before: α : Type ?u.149199
β : Type ?u.149202
γ : Type u_1
γ₂ : Type ?u.149208
δ : Type u_2
ι : Sort y
s t u : Set α
inst✝¹² : TopologicalSpace α
inst✝¹¹ : MeasurableSpace α
inst✝¹⁰ : OpensMeasurableSpace α
inst✝⁹ : TopologicalSpace β
inst✝⁸ : MeasurableSpace β
inst✝⁷ : OpensMeasurableSpace β
inst✝⁶ : TopologicalSpace γ
inst✝⁵ : MeasurableSpace γ
inst✝⁴ : BorelSpace γ
inst✝³ : TopologicalSpace γ₂
inst✝² : MeasurableSpace γ₂
inst✝¹ : BorelSpace γ₂
inst✝ : MeasurableSpace δ
f : δ → γ
hf : ∀ (s : Set γ), IsOpen s → MeasurableSet (f ⁻¹' s)
⊢ Measurable f

tactic: exact measurable_generateFrom hf
state_before: α : Type ?u.149199
β : Type ?u.149202
γ : Type u_1
γ₂ : Type ?u.149208
δ : Type u_2
ι : Sort y
s t u : Set α
inst✝¹² : TopologicalSpace α
inst✝¹¹ : MeasurableSpace α
inst✝¹⁰ : OpensMeasurableSpace α
inst✝⁹ : TopologicalSpace β
inst✝⁸ : MeasurableSpace β
inst✝⁷ : OpensMeasurableSpace β
inst✝⁶ : TopologicalSpace γ
inst✝⁵ : MeasurableSpace γ
inst✝⁴ : BorelSpace γ
inst✝³ : TopologicalSpace γ₂
inst✝² : MeasurableSpace γ₂
inst✝¹ : BorelSpace γ₂
inst✝ : MeasurableSpace δ
f : δ → γ
hf : ∀ (s : Set γ), IsOpen s → MeasurableSet (f ⁻¹' s)
⊢ Measurable f
Theorem: IsCompact.exists_mem_frontier_infDist_compl_eq_dist
File: Mathlib/Analysis/NormedSpace/FiniteDimension.lean

tactic: obtain hx' | hx' : x ∈ interior K ∪ frontier K := by
  rw [← closure_eq_interior_union_frontier]
  exact subset_closure hx
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : Nontrivial E
x : E
K : Set E
hK : IsCompact K
hx : x ∈ K
⊢ ∃ y, y ∈ frontier K ∧ Metric.infDist x (Kᶜ) = dist x y

tactic: rw [← closure_eq_interior_union_frontier]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : Nontrivial E
x : E
K : Set E
hK : IsCompact K
hx : x ∈ K
⊢ x ∈ interior K ∪ frontier K

tactic: exact subset_closure hx
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : Nontrivial E
x : E
K : Set E
hK : IsCompact K
hx : x ∈ K
⊢ x ∈ closure K

tactic: rw [mem_interior_iff_mem_nhds, Metric.nhds_basis_closedBall.mem_iff] at hx'
state_before: case inl
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : Nontrivial E
x : E
K : Set E
hK : IsCompact K
hx : x ∈ K
hx' : x ∈ interior K
⊢ ∃ y, y ∈ frontier K ∧ Metric.infDist x (Kᶜ) = dist x y

tactic: rcases hx' with ⟨r, hr₀, hrK⟩
state_before: case inl
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : Nontrivial E
x : E
K : Set E
hK : IsCompact K
hx : x ∈ K
hx' : ∃ i, 0 < i ∧ Metric.closedBall x i ⊆ K
⊢ ∃ y, y ∈ frontier K ∧ Metric.infDist x (Kᶜ) = dist x y

tactic: have : FiniteDimensional ℝ E :=
  finiteDimensional_of_isCompact_closedBall ℝ hr₀
    (isCompact_of_isClosed_subset hK Metric.isClosed_ball hrK)
state_before: case inl.intro.intro
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : Nontrivial E
x : E
K : Set E
hK : IsCompact K
hx : x ∈ K
r : ℝ
hr₀ : 0 < r
hrK : Metric.closedBall x r ⊆ K
⊢ ∃ y, y ∈ frontier K ∧ Metric.infDist x (Kᶜ) = dist x y

tactic: exact exists_mem_frontier_infDist_compl_eq_dist hx hK.ne_univ
state_before: case inl.intro.intro
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : Nontrivial E
x : E
K : Set E
hK : IsCompact K
hx : x ∈ K
r : ℝ
hr₀ : 0 < r
hrK : Metric.closedBall x r ⊆ K
this : FiniteDimensional ℝ E
⊢ ∃ y, y ∈ frontier K ∧ Metric.infDist x (Kᶜ) = dist x y

tactic: refine' ⟨x, hx', _⟩
state_before: case inr
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : Nontrivial E
x : E
K : Set E
hK : IsCompact K
hx : x ∈ K
hx' : x ∈ frontier K
⊢ ∃ y, y ∈ frontier K ∧ Metric.infDist x (Kᶜ) = dist x y

tactic: rw [frontier_eq_closure_inter_closure] at hx'
state_before: case inr
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : Nontrivial E
x : E
K : Set E
hK : IsCompact K
hx : x ∈ K
hx' : x ∈ frontier K
⊢ Metric.infDist x (Kᶜ) = dist x x

tactic: rw [Metric.infDist_zero_of_mem_closure hx'.2, dist_self]
state_before: case inr
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : Nontrivial E
x : E
K : Set E
hK : IsCompact K
hx : x ∈ K
hx' : x ∈ closure K ∩ closure (Kᶜ)
⊢ Metric.infDist x (Kᶜ) = dist x x
Theorem: IntermediateField.botEquiv_def
File: Mathlib/FieldTheory/Adjoin.lean

tactic: simp
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
x : F
⊢ ↑(botEquiv F E) (↑(algebraMap F { x // x ∈ ⊥ }) x) = x
Theorem: inner_re_symm
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [← inner_conj_symm, conj_re]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1223229
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : E
⊢ ↑re (inner x y) = ↑re (inner y x)
Theorem: LucasLehmer.X.right_distrib
File: Mathlib/NumberTheory/LucasLehmer.lean

tactic: ext <;> dsimp <;> ring
state_before: q : ℕ+
x y z : X q
⊢ (x + y) * z = x * z + y * z
Theorem: Int.mul_ediv_assoc'
File: Std/Data/Int/DivMod.lean

tactic: rw [Int.mul_comm, Int.mul_ediv_assoc _ h, Int.mul_comm]
state_before: b a c : Int
h : c ∣ a
⊢ a * b / c = a / c * b
Theorem: FirstOrder.Language.Equiv.realize_sentence
File: Mathlib/ModelTheory/Semantics.lean

tactic: rw [Sentence.Realize, Sentence.Realize, ← g.realize_formula, Unique.eq_default (g ∘ default)]
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type ?u.654592
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
g : M ≃[L] N
φ : Sentence L
⊢ M ⊨ φ ↔ N ⊨ φ
Theorem: LinearMap.ofIsCompl_eq
File: Mathlib/LinearAlgebra/Projection.lean

tactic: ext x
state_before: R : Type u_2
inst✝⁹ : Ring R
E : Type u_1
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type ?u.241525
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type ?u.242488
inst✝² : Semiring S
M : Type ?u.242494
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
h : IsCompl p q
φ : { x // x ∈ p } →ₗ[R] F
ψ : { x // x ∈ q } →ₗ[R] F
χ : E →ₗ[R] F
hφ : ∀ (u : { x // x ∈ p }), ↑φ u = ↑χ ↑u
hψ : ∀ (u : { x // x ∈ q }), ↑ψ u = ↑χ ↑u
⊢ ofIsCompl h φ ψ = χ

tactic: obtain ⟨_, _, rfl, _⟩ := existsUnique_add_of_isCompl h x
state_before: case h
R : Type u_2
inst✝⁹ : Ring R
E : Type u_1
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type ?u.241525
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type ?u.242488
inst✝² : Semiring S
M : Type ?u.242494
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
h : IsCompl p q
φ : { x // x ∈ p } →ₗ[R] F
ψ : { x // x ∈ q } →ₗ[R] F
χ : E →ₗ[R] F
hφ : ∀ (u : { x // x ∈ p }), ↑φ u = ↑χ ↑u
hψ : ∀ (u : { x // x ∈ q }), ↑ψ u = ↑χ ↑u
x : E
⊢ ↑(ofIsCompl h φ ψ) x = ↑χ x

tactic: simp [ofIsCompl, hφ, hψ]
state_before: case h.intro.intro.intro
R : Type u_2
inst✝⁹ : Ring R
E : Type u_1
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type ?u.241525
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type ?u.242488
inst✝² : Semiring S
M : Type ?u.242494
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
h : IsCompl p q
φ : { x // x ∈ p } →ₗ[R] F
ψ : { x // x ∈ q } →ₗ[R] F
χ : E →ₗ[R] F
hφ : ∀ (u : { x // x ∈ p }), ↑φ u = ↑χ ↑u
hψ : ∀ (u : { x // x ∈ q }), ↑ψ u = ↑χ ↑u
w✝¹ : { x // x ∈ p }
w✝ : { x // x ∈ q }
right✝ : ∀ (r : { x // x ∈ p }) (s : { x // x ∈ q }), ↑r + ↑s = ↑w✝¹ + ↑w✝ → r = w✝¹ ∧ s = w✝
⊢ ↑(ofIsCompl h φ ψ) (↑w✝¹ + ↑w✝) = ↑χ (↑w✝¹ + ↑w✝)
Theorem: Metric.uniformInducing_iff
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: simp only [subset_def, Prod.forall, gt_iff_lt, preimage_setOf_eq, Prod_map, mem_setOf]
state_before: α : Type u
β : Type v
X : Type ?u.60022
ι : Type ?u.60025
inst✝¹ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
inst✝ : PseudoMetricSpace β
f : α → β
⊢ (∀ (i' : ℝ), 0 < i' → ∃ i, 0 < i ∧ Prod.map f f ⁻¹' {p | dist p.fst p.snd < i} ⊆ {p | dist p.fst p.snd < i'}) ↔
    ∀ (δ : ℝ), δ > 0 → ∃ ε, ε > 0 ∧ ∀ {a b : α}, dist (f a) (f b) < ε → dist a b < δ
Theorem: max_def_lt
File: Mathlib/Order/Basic.lean

tactic: rw [max_comm, max_def, ← ite_not]
state_before: ι : Type ?u.76638
α : Type u
β : Type v
γ : Type w
π : ι → Type ?u.76649
r : α → α → Prop
inst✝ : LinearOrder α
p : α → Prop
x✝ y✝ x y : α
⊢ max x y = if x < y then y else x

tactic: simp only [not_le]
state_before: ι : Type ?u.76638
α : Type u
β : Type v
γ : Type w
π : ι → Type ?u.76649
r : α → α → Prop
inst✝ : LinearOrder α
p : α → Prop
x✝ y✝ x y : α
⊢ (if ¬y ≤ x then y else x) = if x < y then y else x
Theorem: PowerSeries.rescale_zero_apply
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: simp
state_before: R : Type u_1
inst✝ : CommSemiring R
⊢ ↑(rescale 0) X = ↑(C R) (↑(constantCoeff R) X)
Theorem: Set.Countable.exists_pos_forall_sum_le
File: Mathlib/Analysis/SpecificLimits/Basic.lean

tactic: rcases hs.exists_pos_hasSum_le hε with ⟨ε', hpos, c, hε'c, hcε⟩
state_before: α : Type ?u.475376
β : Type ?u.475379
ι✝ : Type ?u.475382
ι : Type u_1
s : Set ι
hs : Set.Countable s
ε : ℝ
hε : 0 < ε
⊢ ∃ ε', (∀ (i : ι), 0 < ε' i) ∧ ∀ (t : Finset ι), ↑t ⊆ s → ∑ i in t, ε' i ≤ ε

tactic: refine' ⟨ε', hpos, fun t ht => _⟩
state_before: case intro.intro.intro.intro
α : Type ?u.475376
β : Type ?u.475379
ι✝ : Type ?u.475382
ι : Type u_1
s : Set ι
hs : Set.Countable s
ε : ℝ
hε : 0 < ε
ε' : ι → ℝ
hpos : ∀ (i : ι), 0 < ε' i
c : ℝ
hε'c : HasSum (fun i => ε' ↑i) c
hcε : c ≤ ε
⊢ ∃ ε', (∀ (i : ι), 0 < ε' i) ∧ ∀ (t : Finset ι), ↑t ⊆ s → ∑ i in t, ε' i ≤ ε

tactic: rw [← sum_subtype_of_mem _ ht]
state_before: case intro.intro.intro.intro
α : Type ?u.475376
β : Type ?u.475379
ι✝ : Type ?u.475382
ι : Type u_1
s : Set ι
hs : Set.Countable s
ε : ℝ
hε : 0 < ε
ε' : ι → ℝ
hpos : ∀ (i : ι), 0 < ε' i
c : ℝ
hε'c : HasSum (fun i => ε' ↑i) c
hcε : c ≤ ε
t : Finset ι
ht : ↑t ⊆ s
⊢ ∑ i in t, ε' i ≤ ε

tactic: refine' (sum_le_hasSum _ _ hε'c).trans hcε
state_before: case intro.intro.intro.intro
α : Type ?u.475376
β : Type ?u.475379
ι✝ : Type ?u.475382
ι : Type u_1
s : Set ι
hs : Set.Countable s
ε : ℝ
hε : 0 < ε
ε' : ι → ℝ
hpos : ∀ (i : ι), 0 < ε' i
c : ℝ
hε'c : HasSum (fun i => ε' ↑i) c
hcε : c ≤ ε
t : Finset ι
ht : ↑t ⊆ s
⊢ ∑ x in Finset.subtype (fun x => x ∈ s) t, ε' ↑x ≤ ε

tactic: exact fun _ _ => (hpos _).le
state_before: case intro.intro.intro.intro
α : Type ?u.475376
β : Type ?u.475379
ι✝ : Type ?u.475382
ι : Type u_1
s : Set ι
hs : Set.Countable s
ε : ℝ
hε : 0 < ε
ε' : ι → ℝ
hpos : ∀ (i : ι), 0 < ε' i
c : ℝ
hε'c : HasSum (fun i => ε' ↑i) c
hcε : c ≤ ε
t : Finset ι
ht : ↑t ⊆ s
⊢ ∀ (i : ↑s), ¬i ∈ Finset.subtype (fun x => x ∈ s) t → 0 ≤ ε' ↑i
Theorem: nhds_def'
File: Mathlib/Topology/Basic.lean

tactic: simp only [nhds_def, mem_setOf_eq, @and_comm (a ∈ _), iInf_and]
state_before: α : Type u
β : Type v
ι : Sort w
a✝ : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
a : α
⊢ 𝓝 a = ⨅ (s : Set α) (_ : IsOpen s) (_ : a ∈ s), 𝓟 s
Theorem: Filter.Tendsto.atTop_mul_atTop
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: refine' tendsto_atTop_mono' _ _ hg
state_before: ι : Type ?u.175674
ι' : Type ?u.175677
α : Type u_2
β : Type u_1
γ : Type ?u.175686
inst✝ : StrictOrderedSemiring α
l : Filter β
f g : β → α
hf : Tendsto f l atTop
hg : Tendsto g l atTop
⊢ Tendsto (fun x => f x * g x) l atTop

tactic: filter_upwards [hg.eventually (eventually_ge_atTop 0),
  hf.eventually (eventually_ge_atTop 1)]with _ using le_mul_of_one_le_left
state_before: ι : Type ?u.175674
ι' : Type ?u.175677
α : Type u_2
β : Type u_1
γ : Type ?u.175686
inst✝ : StrictOrderedSemiring α
l : Filter β
f g : β → α
hf : Tendsto f l atTop
hg : Tendsto g l atTop
⊢ g ≤ᶠ[l] fun x => f x * g x
Theorem: Finset.map_subtype_embedding_Iio
File: Mathlib/Order/LocallyFinite.lean

tactic: rw [subtype_Iio_eq]
state_before: α : Type u_1
β : Type ?u.226217
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrderBot α
a : Subtype p
hp : ∀ ⦃a x : α⦄, x ≤ a → p a → p x
⊢ map (Embedding.subtype p) (Iio a) = Iio ↑a

tactic: exact Finset.subtype_map_of_mem fun x hx => hp (mem_Iio.1 hx).le a.prop
state_before: α : Type u_1
β : Type ?u.226217
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrderBot α
a : Subtype p
hp : ∀ ⦃a x : α⦄, x ≤ a → p a → p x
⊢ map (Embedding.subtype p) (Finset.subtype p (Iio ↑a)) = Iio ↑a
Theorem: Polynomial.sum_C_mul_X_pow_eq
File: Mathlib/Data/Polynomial/Basic.lean

tactic: simp_rw [C_mul_X_pow_eq_monomial, sum_monomial_eq]
state_before: R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p✝ q p : R[X]
⊢ (sum p fun n a => ↑C a * X ^ n) = p
Theorem: Valuation.Integers.isUnit_of_one
File: Mathlib/RingTheory/Valuation/Integers.lean

tactic: rw [← one_mul (v _), ← hvx, ← v.map_mul, ← hu, u.mul_inv, hu, hvx, v.map_one]
state_before: R : Type u
Γ₀ : Type v
inst✝⁵ : CommRing R
inst✝⁴ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
O : Type w
inst✝³ : CommRing O
inst✝² : Algebra O R
inst✝¹ : CommRing O
inst✝ : Algebra O R
hv : Integers v O
x : O
hx : IsUnit (↑(algebraMap O R) x)
hvx : ↑v (↑(algebraMap O R) x) = 1
u : ((fun x => R) x)ˣ
hu : ↑u = ↑(algebraMap O R) x
h1 : ↑v ↑u ≤ 1
⊢ ↑v ↑u⁻¹ ≤ 1

tactic: rw [RingHom.map_mul, RingHom.map_one, hr1, hr2, Units.mul_inv]
state_before: R : Type u
Γ₀ : Type v
inst✝⁵ : CommRing R
inst✝⁴ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
O : Type w
inst✝³ : CommRing O
inst✝² : Algebra O R
inst✝¹ : CommRing O
inst✝ : Algebra O R
hv : Integers v O
x : O
hx : IsUnit (↑(algebraMap O R) x)
hvx : ↑v (↑(algebraMap O R) x) = 1
u : ((fun x => R) x)ˣ
hu : ↑u = ↑(algebraMap O R) x
h1 : ↑v ↑u ≤ 1
h2 : ↑v ↑u⁻¹ ≤ 1
r1 : O
hr1 : ↑(algebraMap O R) r1 = ↑u
r2 : O
hr2 : ↑(algebraMap O R) r2 = ↑u⁻¹
⊢ ↑(algebraMap O R) (r1 * r2) = ↑(algebraMap O R) 1

tactic: rw [RingHom.map_mul, RingHom.map_one, hr1, hr2, Units.inv_mul]
state_before: R : Type u
Γ₀ : Type v
inst✝⁵ : CommRing R
inst✝⁴ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
O : Type w
inst✝³ : CommRing O
inst✝² : Algebra O R
inst✝¹ : CommRing O
inst✝ : Algebra O R
hv : Integers v O
x : O
hx : IsUnit (↑(algebraMap O R) x)
hvx : ↑v (↑(algebraMap O R) x) = 1
u : ((fun x => R) x)ˣ
hu : ↑u = ↑(algebraMap O R) x
h1 : ↑v ↑u ≤ 1
h2 : ↑v ↑u⁻¹ ≤ 1
r1 : O
hr1 : ↑(algebraMap O R) r1 = ↑u
r2 : O
hr2 : ↑(algebraMap O R) r2 = ↑u⁻¹
⊢ ↑(algebraMap O R) (r2 * r1) = ↑(algebraMap O R) 1
Theorem: countable_setOf_isolated_right
File: Mathlib/Topology/Order/Basic.lean

tactic: simp only [nhdsWithin_Ioi_eq_bot_iff, setOf_or]
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : SecondCountableTopology α
⊢ Set.Countable {x | 𝓝[Ioi x] x = ⊥}

tactic: exact (subsingleton_isTop α).countable.union countable_setOf_covby_right
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : SecondCountableTopology α
⊢ Set.Countable ({a | IsTop a} ∪ {a | ∃ b, a ⋖ b})
Theorem: Int.card_Ico
File: Mathlib/Data/Int/Interval.lean

tactic: change (Finset.map _ _).card = _
state_before: a b : ℤ
⊢ card (Ico a b) = toNat (b - a)

tactic: rw [Finset.card_map, Finset.card_range]
state_before: a b : ℤ
⊢ card (map (Function.Embedding.trans Nat.castEmbedding (addLeftEmbedding a)) (range (toNat (b - a)))) = toNat (b - a)