tasksource/leandojo huggingface dataset:
Theorem: exists_clopen_upper_or_lower_of_ne
File: Mathlib/Topology/Order/Priestley.lean

tactic: obtain h | h := h.not_le_or_not_le
state_before: α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : PartialOrder α
inst✝ : PriestleySpace α
x y : α
h : x ≠ y
⊢ ∃ U, IsClopen U ∧ (IsUpperSet U ∨ IsLowerSet U) ∧ x ∈ U ∧ ¬y ∈ U

tactic: exact (exists_clopen_upper_of_not_le h).imp fun _ ↦ And.imp_right <| And.imp_left Or.inl
state_before: case inl
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : PartialOrder α
inst✝ : PriestleySpace α
x y : α
h✝ : x ≠ y
h : ¬x ≤ y
⊢ ∃ U, IsClopen U ∧ (IsUpperSet U ∨ IsLowerSet U) ∧ x ∈ U ∧ ¬y ∈ U

tactic: obtain ⟨U, hU, hU', hy, hx⟩ := exists_clopen_lower_of_not_le h
state_before: case inr
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : PartialOrder α
inst✝ : PriestleySpace α
x y : α
h✝ : x ≠ y
h : ¬y ≤ x
⊢ ∃ U, IsClopen U ∧ (IsUpperSet U ∨ IsLowerSet U) ∧ x ∈ U ∧ ¬y ∈ U

tactic: exact ⟨U, hU, Or.inr hU', hx, hy⟩
state_before: case inr.intro.intro.intro.intro
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : PartialOrder α
inst✝ : PriestleySpace α
x y : α
h✝ : x ≠ y
h : ¬y ≤ x
U : Set α
hU : IsClopen U
hU' : IsLowerSet U
hy : ¬y ∈ U
hx : x ∈ U
⊢ ∃ U, IsClopen U ∧ (IsUpperSet U ∨ IsLowerSet U) ∧ x ∈ U ∧ ¬y ∈ U
Theorem: Nat.cons_self_properDivisors
File: Mathlib/NumberTheory/Divisors.lean

tactic: rw [cons_eq_insert, insert_self_properDivisors h]
state_before: n : ℕ
h : n ≠ 0
⊢ cons n (properDivisors n) (_ : ¬n ∈ properDivisors n) = divisors n
Theorem: Polynomial.Chebyshev.aeval_U
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Chebyshev.lean

tactic: rw [aeval_def, eval₂_eq_eval_map, map_U]
state_before: R : Type u_2
A : Type u_1
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Algebra R A
x : A
n : ℕ
⊢ ↑(aeval x) (U R n) = eval x (U A n)
Theorem: deriv.lhopital_zero_nhds_right
File: Mathlib/Analysis/Calculus/LHopital.lean

tactic: have hdg : ∀ᶠ x in 𝓝[>] a, DifferentiableAt ℝ g x :=
  hg'.mp (eventually_of_forall fun _ hg' =>
    by_contradiction fun h => hg' (deriv_zero_of_not_differentiableAt h))
state_before: a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hdf : ∀ᶠ (x : ℝ) in 𝓝[Ioi a] a, DifferentiableAt ℝ f x
hg' : ∀ᶠ (x : ℝ) in 𝓝[Ioi a] a, deriv g x ≠ 0
hfa : Tendsto f (𝓝[Ioi a] a) (𝓝 0)
hga : Tendsto g (𝓝[Ioi a] a) (𝓝 0)
hdiv : Tendsto (fun x => deriv f x / deriv g x) (𝓝[Ioi a] a) l
⊢ Tendsto (fun x => f x / g x) (𝓝[Ioi a] a) l

tactic: have hdf' : ∀ᶠ x in 𝓝[>] a, HasDerivAt f (deriv f x) x :=
  hdf.mp (eventually_of_forall fun _ => DifferentiableAt.hasDerivAt)
state_before: a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hdf : ∀ᶠ (x : ℝ) in 𝓝[Ioi a] a, DifferentiableAt ℝ f x
hg' : ∀ᶠ (x : ℝ) in 𝓝[Ioi a] a, deriv g x ≠ 0
hfa : Tendsto f (𝓝[Ioi a] a) (𝓝 0)
hga : Tendsto g (𝓝[Ioi a] a) (𝓝 0)
hdiv : Tendsto (fun x => deriv f x / deriv g x) (𝓝[Ioi a] a) l
hdg : ∀ᶠ (x : ℝ) in 𝓝[Ioi a] a, DifferentiableAt ℝ g x
⊢ Tendsto (fun x => f x / g x) (𝓝[Ioi a] a) l

tactic: have hdg' : ∀ᶠ x in 𝓝[>] a, HasDerivAt g (deriv g x) x :=
  hdg.mp (eventually_of_forall fun _ => DifferentiableAt.hasDerivAt)
state_before: a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hdf : ∀ᶠ (x : ℝ) in 𝓝[Ioi a] a, DifferentiableAt ℝ f x
hg' : ∀ᶠ (x : ℝ) in 𝓝[Ioi a] a, deriv g x ≠ 0
hfa : Tendsto f (𝓝[Ioi a] a) (𝓝 0)
hga : Tendsto g (𝓝[Ioi a] a) (𝓝 0)
hdiv : Tendsto (fun x => deriv f x / deriv g x) (𝓝[Ioi a] a) l
hdg : ∀ᶠ (x : ℝ) in 𝓝[Ioi a] a, DifferentiableAt ℝ g x
hdf' : ∀ᶠ (x : ℝ) in 𝓝[Ioi a] a, HasDerivAt f (deriv f x) x
⊢ Tendsto (fun x => f x / g x) (𝓝[Ioi a] a) l

tactic: exact HasDerivAt.lhopital_zero_nhds_right hdf' hdg' hg' hfa hga hdiv
state_before: a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hdf : ∀ᶠ (x : ℝ) in 𝓝[Ioi a] a, DifferentiableAt ℝ f x
hg' : ∀ᶠ (x : ℝ) in 𝓝[Ioi a] a, deriv g x ≠ 0
hfa : Tendsto f (𝓝[Ioi a] a) (𝓝 0)
hga : Tendsto g (𝓝[Ioi a] a) (𝓝 0)
hdiv : Tendsto (fun x => deriv f x / deriv g x) (𝓝[Ioi a] a) l
hdg : ∀ᶠ (x : ℝ) in 𝓝[Ioi a] a, DifferentiableAt ℝ g x
hdf' : ∀ᶠ (x : ℝ) in 𝓝[Ioi a] a, HasDerivAt f (deriv f x) x
hdg' : ∀ᶠ (x : ℝ) in 𝓝[Ioi a] a, HasDerivAt g (deriv g x) x
⊢ Tendsto (fun x => f x / g x) (𝓝[Ioi a] a) l
Theorem: mul_inv_lt_iff_lt_mul
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [← mul_lt_mul_iff_right b, inv_mul_cancel_right]
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LT α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c : α
⊢ a * b⁻¹ < c ↔ a < c * b
Theorem: isCompact_isCompact_separated
File: Mathlib/Topology/Separation.lean

tactic: simp only [SeparatedNhds, prod_subset_compl_diagonal_iff_disjoint.symm] at hst ⊢
state_before: α : Type u
β : Type v
inst✝³ : TopologicalSpace α
γ : Type ?u.127862
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : T2Space α
s t : Set α
hs : IsCompact s
ht : IsCompact t
hst : Disjoint s t
⊢ SeparatedNhds s t

tactic: exact generalized_tube_lemma hs ht isClosed_diagonal.isOpen_compl hst
state_before: α : Type u
β : Type v
inst✝³ : TopologicalSpace α
γ : Type ?u.127862
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : T2Space α
s t : Set α
hs : IsCompact s
ht : IsCompact t
hst : s ×ˢ t ⊆ diagonal αᶜ
⊢ ∃ U V, IsOpen U ∧ IsOpen V ∧ s ⊆ U ∧ t ⊆ V ∧ U ×ˢ V ⊆ diagonal αᶜ
Theorem: List.rotate_one_eq_self_iff_eq_replicate
File: Mathlib/Data/List/Rotate.lean

tactic: rwa [Nat.succ_eq_add_one, ← l.rotate_rotate, hn]
state_before: α : Type u
inst✝ : Nonempty α
l : List α
h : rotate l 1 = l
n✝ n : ℕ
hn : rotate l n = l
⊢ rotate l (succ n) = l
Theorem: PrimeMultiset.prod_add
File: Mathlib/Data/PNat/Factors.lean

tactic: change (coePNatMonoidHom (u + v)).prod = _
state_before: u v : PrimeMultiset
⊢ prod (u + v) = prod u * prod v

tactic: rw [coePNatMonoidHom.map_add]
state_before: u v : PrimeMultiset
⊢ Multiset.prod (↑coePNatMonoidHom (u + v)) = prod u * prod v

tactic: exact Multiset.prod_add _ _
state_before: u v : PrimeMultiset
⊢ Multiset.prod (↑coePNatMonoidHom u + ↑coePNatMonoidHom v) = prod u * prod v
Theorem: CategoryTheory.MonoidalCategory.tensorHom_inv_id'
File: Mathlib/CategoryTheory/Monoidal/Category.lean

tactic: rw [← tensor_comp, IsIso.hom_inv_id, comp_tensor_id]
state_before: C✝ : Type u
𝒞 : Category C✝
inst✝³ : MonoidalCategory C✝
C : Type u
inst✝² : Category C
inst✝¹ : MonoidalCategory C
U V✝ W✝ X✝ Y✝ Z✝ V W X Y Z : C
f : V ⟶ W
inst✝ : IsIso f
g : X ⟶ Y
h : Y ⟶ Z
⊢ (g ⊗ f) ≫ (h ⊗ inv f) = (g ⊗ 𝟙 V) ≫ (h ⊗ 𝟙 V)
Theorem: Ordinal.mul_isLimit_left
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rcases zero_or_succ_or_limit b with (rfl | ⟨b, rfl⟩ | lb)
state_before: α : Type ?u.221106
β : Type ?u.221109
γ : Type ?u.221112
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal
l : IsLimit a
b0 : 0 < b
⊢ IsLimit (a * b)

tactic: exact b0.false.elim
state_before: case inl
α : Type ?u.221106
β : Type ?u.221109
γ : Type ?u.221112
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a : Ordinal
l : IsLimit a
b0 : 0 < 0
⊢ IsLimit (a * 0)

tactic: rw [mul_succ]
state_before: case inr.inl.intro
α : Type ?u.221106
β : Type ?u.221109
γ : Type ?u.221112
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a : Ordinal
l : IsLimit a
b : Ordinal
b0 : 0 < succ b
⊢ IsLimit (a * succ b)

tactic: exact add_isLimit _ l
state_before: case inr.inl.intro
α : Type ?u.221106
β : Type ?u.221109
γ : Type ?u.221112
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a : Ordinal
l : IsLimit a
b : Ordinal
b0 : 0 < succ b
⊢ IsLimit (a * b + a)

tactic: exact mul_isLimit l.pos lb
state_before: case inr.inr
α : Type ?u.221106
β : Type ?u.221109
γ : Type ?u.221112
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal
l : IsLimit a
b0 : 0 < b
lb : IsLimit b
⊢ IsLimit (a * b)
Theorem: Finset.min_of_mem
File: Mathlib/Data/Finset/Lattice.lean

tactic: obtain ⟨b, h, _⟩ := inf_le (α := WithTop α) h _ rfl
state_before: F : Type ?u.324381
α : Type u_1
β : Type ?u.324387
γ : Type ?u.324390
ι : Type ?u.324393
κ : Type ?u.324396
inst✝ : LinearOrder α
s : Finset α
a : α
h : a ∈ s
⊢ ∃ b, Finset.min s = ↑b

tactic: exact ⟨b, h⟩
state_before: case intro.intro
F : Type ?u.324381
α : Type u_1
β : Type ?u.324387
γ : Type ?u.324390
ι : Type ?u.324393
κ : Type ?u.324396
inst✝ : LinearOrder α
s : Finset α
a : α
h✝ : a ∈ s
b : α
h : b ∈ inf s some
right✝ : b ≤ a
⊢ ∃ b, Finset.min s = ↑b
Theorem: Finset.orderEmbOfFin_singleton
File: Mathlib/Data/Finset/Sort.lean

tactic: rw [Subsingleton.elim i ⟨0, zero_lt_one⟩, orderEmbOfFin_zero _ zero_lt_one, min'_singleton]
state_before: α : Type u_1
β : Type ?u.49125
inst✝ : LinearOrder α
a : α
i : Fin 1
⊢ ↑(orderEmbOfFin {a} (_ : card {a} = 1)) i = a
Theorem: Ordinal.lift_type_lt
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: haveI := @RelEmbedding.isWellOrder _ _ (@Equiv.ulift.{max v w} α ⁻¹'o r) r
  (RelIso.preimage Equiv.ulift.{max v w} r) _
state_before: α✝ : Type ?u.108718
β✝ : Type ?u.108721
γ : Type ?u.108724
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
α : Type u
β : Type v
r : α → α → Prop
s : β → β → Prop
inst✝¹ : IsWellOrder α r
inst✝ : IsWellOrder β s
⊢ lift (type r) < lift (type s) ↔ Nonempty (r ≺i s)

tactic: haveI := @RelEmbedding.isWellOrder _ _ (@Equiv.ulift.{max u w} β ⁻¹'o s) s
  (RelIso.preimage Equiv.ulift.{max u w} s) _
state_before: α✝ : Type ?u.108718
β✝ : Type ?u.108721
γ : Type ?u.108724
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
α : Type u
β : Type v
r : α → α → Prop
s : β → β → Prop
inst✝¹ : IsWellOrder α r
inst✝ : IsWellOrder β s
this : IsWellOrder (ULift α) (↑Equiv.ulift ⁻¹'o r)
⊢ lift (type r) < lift (type s) ↔ Nonempty (r ≺i s)

tactic: exact ⟨fun ⟨f⟩ =>
  ⟨(f.equivLT (RelIso.preimage Equiv.ulift r).symm).ltLe
      (InitialSeg.ofIso (RelIso.preimage Equiv.ulift s))⟩,
  fun ⟨f⟩ =>
  ⟨(f.equivLT (RelIso.preimage Equiv.ulift r)).ltLe
      (InitialSeg.ofIso (RelIso.preimage Equiv.ulift s).symm)⟩⟩
state_before: α✝ : Type ?u.108718
β✝ : Type ?u.108721
γ : Type ?u.108724
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
α : Type u
β : Type v
r : α → α → Prop
s : β → β → Prop
inst✝¹ : IsWellOrder α r
inst✝ : IsWellOrder β s
this✝ : IsWellOrder (ULift α) (↑Equiv.ulift ⁻¹'o r)
this : IsWellOrder (ULift β) (↑Equiv.ulift ⁻¹'o s)
⊢ lift (type r) < lift (type s) ↔ Nonempty (r ≺i s)
Theorem: List.dropWhile_idempotent
File: Mathlib/Data/List/Rdrop.lean

tactic: simp only [dropWhile_eq_self_iff]
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
⊢ dropWhile p (dropWhile p l) = dropWhile p l

tactic: exact fun h => dropWhile_nthLe_zero_not p l h
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
⊢ ∀ (hl : 0 < length (dropWhile p l)), ¬p (nthLe (dropWhile p l) 0 hl) = true
Theorem: Nat.descFactorial_eq_factorial_mul_choose
File: Mathlib/Data/Nat/Choose/Basic.lean

tactic: obtain h | h := Nat.lt_or_ge n k
state_before: n k : ℕ
⊢ descFactorial n k = k ! * choose n k

tactic: rw [mul_comm]
state_before: case inr
n k : ℕ
h : n ≥ k
⊢ descFactorial n k = k ! * choose n k

tactic: apply mul_right_cancel₀ (factorial_ne_zero (n - k))
state_before: case inr
n k : ℕ
h : n ≥ k
⊢ descFactorial n k = choose n k * k !

tactic: rw [choose_mul_factorial_mul_factorial h, ← factorial_mul_descFactorial h, mul_comm]
state_before: case inr
n k : ℕ
h : n ≥ k
⊢ descFactorial n k * (n - k)! = choose n k * k ! * (n - k)!

tactic: rw [descFactorial_eq_zero_iff_lt.2 h, choose_eq_zero_of_lt h, mul_zero]
state_before: case inl
n k : ℕ
h : n < k
⊢ descFactorial n k = k ! * choose n k
Theorem: CategoryTheory.Limits.prod_rightUnitor_inv_naturality
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: rw [Iso.inv_comp_eq, ← Category.assoc, Iso.eq_comp_inv, prod.rightUnitor_hom_naturality]
state_before: C : Type u
inst✝² : Category C
X Y : C
inst✝¹ : HasTerminal C
inst✝ : HasBinaryProducts C
f : X ⟶ Y
⊢ (prod.rightUnitor X).inv ≫ prod.map f (𝟙 (⊤_ C)) = f ≫ (prod.rightUnitor Y).inv
Theorem: FirstOrder.Language.card_eq_card_functions_add_card_relations
File: Mathlib/ModelTheory/Basic.lean

tactic: simp [card, Symbols]
state_before: L : Language
L' : Language
⊢ card L = (sum fun l => lift (#Functions L l)) + sum fun l => lift (#Relations L l)
Theorem: dist_lineMap_lineMap
File: Mathlib/Analysis/NormedSpace/AddTorsor.lean

tactic: rw [dist_comm p₁ p₂]
state_before: α : Type ?u.17388
V : Type u_3
P : Type u_1
W : Type ?u.17397
Q : Type ?u.17400
inst✝⁸ : SeminormedAddCommGroup V
inst✝⁷ : PseudoMetricSpace P
inst✝⁶ : NormedAddTorsor V P
inst✝⁵ : NormedAddCommGroup W
inst✝⁴ : MetricSpace Q
inst✝³ : NormedAddTorsor W Q
𝕜 : Type u_2
inst✝² : NormedField 𝕜
inst✝¹ : NormedSpace 𝕜 V
inst✝ : NormedSpace 𝕜 W
p₁ p₂ : P
c₁ c₂ : 𝕜
⊢ dist (↑(lineMap p₁ p₂) c₁) (↑(lineMap p₁ p₂) c₂) = dist c₁ c₂ * dist p₁ p₂

tactic: rw [lineMap_apply, lineMap_apply, dist_eq_norm_vsub V, vadd_vsub_vadd_cancel_right,
  ← sub_smul, norm_smul, ← vsub_eq_sub, ← dist_eq_norm_vsub V, ← dist_eq_norm_vsub 𝕜]
state_before: α : Type ?u.17388
V : Type u_3
P : Type u_1
W : Type ?u.17397
Q : Type ?u.17400
inst✝⁸ : SeminormedAddCommGroup V
inst✝⁷ : PseudoMetricSpace P
inst✝⁶ : NormedAddTorsor V P
inst✝⁵ : NormedAddCommGroup W
inst✝⁴ : MetricSpace Q
inst✝³ : NormedAddTorsor W Q
𝕜 : Type u_2
inst✝² : NormedField 𝕜
inst✝¹ : NormedSpace 𝕜 V
inst✝ : NormedSpace 𝕜 W
p₁ p₂ : P
c₁ c₂ : 𝕜
⊢ dist (↑(lineMap p₁ p₂) c₁) (↑(lineMap p₁ p₂) c₂) = dist c₁ c₂ * dist p₂ p₁
Theorem: abs_neg
File: Mathlib/Algebra/Order/Group/Abs.lean

tactic: rw [abs_eq_max_neg, max_comm, neg_neg, abs_eq_max_neg]
state_before: α : Type u_1
inst✝¹ : AddGroup α
inst✝ : LinearOrder α
a : α
⊢ abs (-a) = abs a
Theorem: Ideal.minimalPrimes_eq_comap
File: Mathlib/RingTheory/Ideal/MinimalPrime.lean

tactic: rw [minimalPrimes, ← Ideal.comap_minimalPrimes_eq_of_surjective Ideal.Quotient.mk_surjective,
  ← RingHom.ker_eq_comap_bot, Ideal.mk_ker]
state_before: R : Type u_1
S : Type ?u.119170
inst✝¹ : CommRing R
inst✝ : CommRing S
I J : Ideal R
⊢ Ideal.minimalPrimes I = comap (Quotient.mk I) '' minimalPrimes (R ⧸ I)
Theorem: Set.Finite.sep
File: Mathlib/Data/Set/Finite.lean

tactic: cases hs
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
hs : Set.Finite s
p : α → Prop
⊢ Set.Finite {a | a ∈ s ∧ p a}

tactic: apply toFinite
state_before: case intro
α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
p : α → Prop
a✝ : Fintype ↑s
⊢ Set.Finite {a | a ∈ s ∧ p a}
Theorem: Submodule.map_comp
File: Mathlib/LinearAlgebra/Basic.lean

tactic: simp only [← image_comp, map_coe, LinearMap.coe_comp, comp_apply]
state_before: R : Type u_3
R₁ : Type ?u.476879
R₂ : Type u_1
R₃ : Type u_2
R₄ : Type ?u.476888
S : Type ?u.476891
K : Type ?u.476894
K₂ : Type ?u.476897
M : Type u_4
M' : Type ?u.476903
M₁ : Type ?u.476906
M₂ : Type u_5
M₃ : Type u_6
M₄ : Type ?u.476915
N : Type ?u.476918
N₂ : Type ?u.476921
ι : Type ?u.476924
V : Type ?u.476927
V₂ : Type ?u.476930
inst✝¹⁶ : Semiring R
inst✝¹⁵ : Semiring R₂
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₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
σ₂₁ : R₂ →+* R
inst✝⁵ : RingHomInvPair σ₁₂ σ₂₁
inst✝⁴ : RingHomInvPair σ₂₁ σ₁₂
inst✝³ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
p✝ p' : Submodule R M
q q' : Submodule R₂ M₂
q₁ q₁' : Submodule R M'
r : R
x y : M
inst✝² : RingHomSurjective σ₁₂
F : Type ?u.477511
sc : SemilinearMapClass F σ₁₂ M M₂
inst✝¹ : RingHomSurjective σ₂₃
inst✝ : RingHomSurjective σ₁₃
f : M →ₛₗ[σ₁₂] M₂
g : M₂ →ₛₗ[σ₂₃] M₃
p : Submodule R M
⊢ ↑(map (LinearMap.comp g f) p) = ↑(map g (map f p))
Theorem: Ordinal.bsup_congr
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: subst ho
state_before: α : Type ?u.309149
β : Type ?u.309152
γ : Type ?u.309155
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o₁ o₂ : Ordinal
f : (a : Ordinal) → a < o₁ → Ordinal
ho : o₁ = o₂
⊢ bsup o₁ f = bsup o₂ fun a h => f a (_ : a < o₁)

tactic: rfl
state_before: α : Type ?u.309149
β : Type ?u.309152
γ : Type ?u.309155
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o₁ : Ordinal
f : (a : Ordinal) → a < o₁ → Ordinal
⊢ bsup o₁ f = bsup o₁ fun a h => f a (_ : a < o₁)
Theorem: Path.truncate_self
File: Mathlib/Topology/PathConnected.lean

tactic: rw [min_self]
state_before: X✝ : Type ?u.471660
Y : Type ?u.471663
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x y z : X✝
ι : Type ?u.471678
γ✝ : Path x y
X : Type ?u.471727
inst✝ : TopologicalSpace X
a b : X
γ : Path a b
t : ℝ
⊢ extend γ (min t t) = extend γ t

tactic: ext x
state_before: X✝ : Type ?u.471660
Y : Type ?u.471663
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x y z : X✝
ι : Type ?u.471678
γ✝ : Path x y
X : Type u_1
inst✝ : TopologicalSpace X
a b : X
γ : Path a b
t : ℝ
⊢ truncate γ t t = cast (refl (extend γ t)) (_ : extend γ (min t t) = extend γ t) (_ : extend γ t = extend γ t)

tactic: rw [cast_coe]
state_before: case a.h
X✝ : Type ?u.471660
Y : Type ?u.471663
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.471678
γ✝ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b : X
γ : Path a b
t : ℝ
x : ↑I
⊢ ↑(truncate γ t t) x =
    ↑(cast (refl (extend γ t)) (_ : extend γ (min t t) = extend γ t) (_ : extend γ t = extend γ t)) x

tactic: simp only [truncate, FunLike.coe, refl, min_def, max_def]
state_before: case a.h
X✝ : Type ?u.471660
Y : Type ?u.471663
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.471678
γ✝ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b : X
γ : Path a b
t : ℝ
x : ↑I
⊢ ↑(truncate γ t t) x = ↑(refl (extend γ t)) x

tactic: split_ifs with h₁ h₂ <;> congr
state_before: case a.h
X✝ : Type ?u.471660
Y : Type ?u.471663
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.471678
γ✝ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b : X
γ : Path a b
t : ℝ
x : ↑I
⊢ extend γ (if (if ↑x ≤ t then t else ↑x) ≤ t then if ↑x ≤ t then t else ↑x else t) = extend γ t
Theorem: ContractingWith.eq_or_edist_eq_top_of_fixedPoints
File: Mathlib/Topology/MetricSpace/Contracting.lean

tactic: refine' or_iff_not_imp_right.2 fun h ↦ edist_le_zero.1 _
state_before: α : Type u_1
inst✝ : EMetricSpace α
cs : CompleteSpace α
K : ℝ≥0
f : α → α
hf : ContractingWith K f
x y : α
hx : IsFixedPt f x
hy : IsFixedPt f y
⊢ x = y ∨ edist x y = ⊤

tactic: simpa only [hx.eq, edist_self, add_zero, ENNReal.zero_div] using hf.edist_le_of_fixedPoint h hy
state_before: α : Type u_1
inst✝ : EMetricSpace α
cs : CompleteSpace α
K : ℝ≥0
f : α → α
hf : ContractingWith K f
x y : α
hx : IsFixedPt f x
hy : IsFixedPt f y
h : ¬edist x y = ⊤
⊢ edist x y ≤ 0
Theorem: LieAlgebra.abelian_iff_derived_one_eq_bot
File: Mathlib/Algebra/Lie/Solvable.lean

tactic: rw [derivedSeriesOfIdeal_succ, derivedSeriesOfIdeal_zero,
  LieSubmodule.lie_abelian_iff_lie_self_eq_bot]
state_before: R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
⊢ IsLieAbelian { x // x ∈ ↑I } ↔ D 1 I = ⊥
Theorem: EuclideanGeometry.eq_orthogonalProjection_of_eq_subspace
File: Mathlib/Geometry/Euclidean/Basic.lean

tactic: subst h
state_before: V : Type u_1
P : Type u_2
inst✝⁷ : NormedAddCommGroup V
inst✝⁶ : InnerProductSpace ℝ V
inst✝⁵ : MetricSpace P
inst✝⁴ : NormedAddTorsor V P
s s' : AffineSubspace ℝ P
inst✝³ : Nonempty { x // x ∈ s }
inst✝² : Nonempty { x // x ∈ s' }
inst✝¹ : CompleteSpace { x // x ∈ direction s }
inst✝ : CompleteSpace { x // x ∈ direction s' }
h : s = s'
p : P
⊢ ↑(↑(orthogonalProjection s) p) = ↑(↑(orthogonalProjection s') p)

tactic: rfl
state_before: V : Type u_1
P : Type u_2
inst✝⁷ : NormedAddCommGroup V
inst✝⁶ : InnerProductSpace ℝ V
inst✝⁵ : MetricSpace P
inst✝⁴ : NormedAddTorsor V P
s : AffineSubspace ℝ P
inst✝³ : Nonempty { x // x ∈ s }
inst✝² : CompleteSpace { x // x ∈ direction s }
p : P
inst✝¹ : Nonempty { x // x ∈ s }
inst✝ : CompleteSpace { x // x ∈ direction s }
⊢ ↑(↑(orthogonalProjection s) p) = ↑(↑(orthogonalProjection s) p)
Theorem: MeasureTheory.set_lintegral_dirac'
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rw [restrict_dirac' hs]
state_before: α : Type u_1
β : Type ?u.1691760
γ : Type ?u.1691763
δ : Type ?u.1691766
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : MeasurableSpace α
a : α
f : α → ℝ≥0∞
hf : Measurable f
s : Set α
hs : MeasurableSet s
inst✝ : Decidable (a ∈ s)
⊢ (∫⁻ (x : α) in s, f x ∂dirac a) = if a ∈ s then f a else 0

tactic: split_ifs
state_before: α : Type u_1
β : Type ?u.1691760
γ : Type ?u.1691763
δ : Type ?u.1691766
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : MeasurableSpace α
a : α
f : α → ℝ≥0∞
hf : Measurable f
s : Set α
hs : MeasurableSet s
inst✝ : Decidable (a ∈ s)
⊢ (∫⁻ (x : α), f x ∂if a ∈ s then dirac a else 0) = if a ∈ s then f a else 0

tactic: exact lintegral_dirac' _ hf
state_before: case inl
α : Type u_1
β : Type ?u.1691760
γ : Type ?u.1691763
δ : Type ?u.1691766
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : MeasurableSpace α
a : α
f : α → ℝ≥0∞
hf : Measurable f
s : Set α
hs : MeasurableSet s
inst✝ : Decidable (a ∈ s)
h✝ : a ∈ s
⊢ (∫⁻ (x : α), f x ∂dirac a) = f a

tactic: exact lintegral_zero_measure _
state_before: case inr
α : Type u_1
β : Type ?u.1691760
γ : Type ?u.1691763
δ : Type ?u.1691766
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : MeasurableSpace α
a : α
f : α → ℝ≥0∞
hf : Measurable f
s : Set α
hs : MeasurableSet s
inst✝ : Decidable (a ∈ s)
h✝ : ¬a ∈ s
⊢ (∫⁻ (x : α), f x ∂0) = 0
Theorem: Real.sin_pi_div_three
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: rw [← cos_pi_div_two_sub, ← cos_pi_div_six]
state_before: x : ℝ
⊢ sin (π / 3) = sqrt 3 / 2

tactic: congr
state_before: x : ℝ
⊢ cos (π / 2 - π / 3) = cos (π / 6)

tactic: ring
state_before: case e_x
x : ℝ
⊢ π / 2 - π / 3 = π / 6
Theorem: CategoryTheory.NatIso.naturality_2
File: Mathlib/CategoryTheory/NatIso.lean

tactic: simp
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
F G : C ⥤ D
X Y : C
α : F ≅ G
f : X ⟶ Y
⊢ α.hom.app X ≫ G.map f ≫ α.inv.app Y = F.map f
Theorem: Prod.Lex.toLex_strictMono
File: Mathlib/Data/Prod/Lex.lean

tactic: rintro ⟨a₁, b₁⟩ ⟨a₂, b₂⟩ h
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.19022
inst✝¹ : PartialOrder α
inst✝ : Preorder β
⊢ StrictMono ↑toLex

tactic: obtain rfl | ha : a₁ = a₂ ∨ _ := h.le.1.eq_or_lt
state_before: case mk.mk
α : Type u_1
β : Type u_2
γ : Type ?u.19022
inst✝¹ : PartialOrder α
inst✝ : Preorder β
a₁ : α
b₁ : β
a₂ : α
b₂ : β
h : (a₁, b₁) < (a₂, b₂)
⊢ ↑toLex (a₁, b₁) < ↑toLex (a₂, b₂)

tactic: exact right _ (Prod.mk_lt_mk_iff_right.1 h)
state_before: case mk.mk.inl
α : Type u_1
β : Type u_2
γ : Type ?u.19022
inst✝¹ : PartialOrder α
inst✝ : Preorder β
a₁ : α
b₁ b₂ : β
h : (a₁, b₁) < (a₁, b₂)
⊢ ↑toLex (a₁, b₁) < ↑toLex (a₁, b₂)

tactic: exact left _ _ ha
state_before: case mk.mk.inr
α : Type u_1
β : Type u_2
γ : Type ?u.19022
inst✝¹ : PartialOrder α
inst✝ : Preorder β
a₁ : α
b₁ : β
a₂ : α
b₂ : β
h : (a₁, b₁) < (a₂, b₂)
ha : (a₁, b₁).fst < (a₂, b₂).fst
⊢ ↑toLex (a₁, b₁) < ↑toLex (a₂, b₂)