tasksource/leandojo huggingface dataset:
Theorem: ModelWithCorners.target_eq
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

tactic: rw [← image_univ, ← I.source_eq]
state_before: 𝕜 : Type u_3
inst✝³ : NontriviallyNormedField 𝕜
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
H : Type u_2
inst✝ : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
⊢ I.target = range ↑I

tactic: exact I.image_source_eq_target.symm
state_before: 𝕜 : Type u_3
inst✝³ : NontriviallyNormedField 𝕜
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
H : Type u_2
inst✝ : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
⊢ I.target = ↑I '' I.source
Theorem: inv_mul_lt_one_iff_lt
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [← mul_lt_mul_iff_right b, inv_mul_cancel_right, one_mul]
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⁻¹ < 1 ↔ a < b
Theorem: Submonoid.LocalizationMap.mk'_one
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: rw [mk', MonoidHom.map_one]
state_before: M : Type u_2
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_1
inst✝¹ : CommMonoid N
P : Type ?u.730830
inst✝ : CommMonoid P
f : LocalizationMap S N
x : M
⊢ mk' f x 1 = ↑(toMap f) x

tactic: exact mul_one _
state_before: M : Type u_2
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_1
inst✝¹ : CommMonoid N
P : Type ?u.730830
inst✝ : CommMonoid P
f : LocalizationMap S N
x : M
⊢ ↑(toMap f) x * ↑1⁻¹ = ↑(toMap f) x
Theorem: Filter.tendsto_iff_ptendsto_univ
File: Mathlib/Order/Filter/Partial.lean

tactic: rw [← tendsto_iff_ptendsto]
state_before: α : Type u
β : Type v
γ : Type w
l₁ : Filter α
l₂ : Filter β
f : α → β
⊢ Tendsto f l₁ l₂ ↔ PTendsto (PFun.res f Set.univ) l₁ l₂

tactic: simp [principal_univ]
state_before: α : Type u
β : Type v
γ : Type w
l₁ : Filter α
l₂ : Filter β
f : α → β
⊢ Tendsto f l₁ l₂ ↔ Tendsto f (l₁ ⊓ 𝓟 Set.univ) l₂
Theorem: Real.cos_pi_div_three
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: have h₁ : (2 * cos (π / 3) - 1) ^ 2 * (2 * cos (π / 3) + 2) = 0 := by
  have : cos (3 * (π / 3)) = cos π := by
    congr 1
    ring
  linarith [cos_pi, cos_three_mul (π / 3)]
state_before: x : ℝ
⊢ cos (π / 3) = 1 / 2

tactic: cases' mul_eq_zero.mp h₁ with h h
state_before: x : ℝ
h₁ : (2 * cos (π / 3) - 1) ^ 2 * (2 * cos (π / 3) + 2) = 0
⊢ cos (π / 3) = 1 / 2

tactic: have : cos (3 * (π / 3)) = cos π := by
  congr 1
  ring
state_before: x : ℝ
⊢ (2 * cos (π / 3) - 1) ^ 2 * (2 * cos (π / 3) + 2) = 0

tactic: linarith [cos_pi, cos_three_mul (π / 3)]
state_before: x : ℝ
this : cos (3 * (π / 3)) = cos π
⊢ (2 * cos (π / 3) - 1) ^ 2 * (2 * cos (π / 3) + 2) = 0

tactic: congr 1
state_before: x : ℝ
⊢ cos (3 * (π / 3)) = cos π

tactic: ring
state_before: case e_x
x : ℝ
⊢ 3 * (π / 3) = π

tactic: linarith [pow_eq_zero h]
state_before: case inl
x : ℝ
h₁ : (2 * cos (π / 3) - 1) ^ 2 * (2 * cos (π / 3) + 2) = 0
h : (2 * cos (π / 3) - 1) ^ 2 = 0
⊢ cos (π / 3) = 1 / 2

tactic: have : cos π < cos (π / 3) := by
  refine' cos_lt_cos_of_nonneg_of_le_pi _ rfl.ge _ <;> linarith [pi_pos]
state_before: case inr
x : ℝ
h₁ : (2 * cos (π / 3) - 1) ^ 2 * (2 * cos (π / 3) + 2) = 0
h : 2 * cos (π / 3) + 2 = 0
⊢ cos (π / 3) = 1 / 2

tactic: linarith [cos_pi]
state_before: case inr
x : ℝ
h₁ : (2 * cos (π / 3) - 1) ^ 2 * (2 * cos (π / 3) + 2) = 0
h : 2 * cos (π / 3) + 2 = 0
this : cos π < cos (π / 3)
⊢ cos (π / 3) = 1 / 2

tactic: refine' cos_lt_cos_of_nonneg_of_le_pi _ rfl.ge _ <;> linarith [pi_pos]
state_before: x : ℝ
h₁ : (2 * cos (π / 3) - 1) ^ 2 * (2 * cos (π / 3) + 2) = 0
h : 2 * cos (π / 3) + 2 = 0
⊢ cos π < cos (π / 3)
Theorem: disjoint_sup_left
File: Mathlib/Order/Disjoint.lean

tactic: simp only [disjoint_iff, inf_sup_right, sup_eq_bot_iff]
state_before: α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
a b c : α
⊢ Disjoint (a ⊔ b) c ↔ Disjoint a c ∧ Disjoint b c
Theorem: Submodule.range_dualMap_mkQ_eq
File: Mathlib/LinearAlgebra/Dual.lean

tactic: ext φ
state_before: R : Type u_1
M : Type u_2
M' : Type ?u.1403652
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup M'
inst✝ : Module R M'
W : Submodule R M
⊢ LinearMap.range (LinearMap.dualMap (mkQ W)) = dualAnnihilator W

tactic: rw [LinearMap.mem_range]
state_before: case h
R : Type u_1
M : Type u_2
M' : Type ?u.1403652
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup M'
inst✝ : Module R M'
W : Submodule R M
φ : Dual R M
⊢ φ ∈ LinearMap.range (LinearMap.dualMap (mkQ W)) ↔ φ ∈ dualAnnihilator W

tactic: constructor
state_before: case h
R : Type u_1
M : Type u_2
M' : Type ?u.1403652
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup M'
inst✝ : Module R M'
W : Submodule R M
φ : Dual R M
⊢ (∃ y, ↑(LinearMap.dualMap (mkQ W)) y = φ) ↔ φ ∈ dualAnnihilator W

tactic: rintro ⟨ψ, rfl⟩
state_before: case h.mp
R : Type u_1
M : Type u_2
M' : Type ?u.1403652
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup M'
inst✝ : Module R M'
W : Submodule R M
φ : Dual R M
⊢ (∃ y, ↑(LinearMap.dualMap (mkQ W)) y = φ) → φ ∈ dualAnnihilator W

tactic: have := LinearMap.mem_range_self W.mkQ.dualMap ψ
state_before: case h.mp.intro
R : Type u_1
M : Type u_2
M' : Type ?u.1403652
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup M'
inst✝ : Module R M'
W : Submodule R M
ψ : Dual R (M ⧸ W)
⊢ ↑(LinearMap.dualMap (mkQ W)) ψ ∈ dualAnnihilator W

tactic: simpa only [ker_mkQ] using LinearMap.range_dualMap_le_dualAnnihilator_ker W.mkQ this
state_before: case h.mp.intro
R : Type u_1
M : Type u_2
M' : Type ?u.1403652
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup M'
inst✝ : Module R M'
W : Submodule R M
ψ : Dual R (M ⧸ W)
this : ↑(LinearMap.dualMap (mkQ W)) ψ ∈ LinearMap.range (LinearMap.dualMap (mkQ W))
⊢ ↑(LinearMap.dualMap (mkQ W)) ψ ∈ dualAnnihilator W

tactic: intro hφ
state_before: case h.mpr
R : Type u_1
M : Type u_2
M' : Type ?u.1403652
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup M'
inst✝ : Module R M'
W : Submodule R M
φ : Dual R M
⊢ φ ∈ dualAnnihilator W → ∃ y, ↑(LinearMap.dualMap (mkQ W)) y = φ

tactic: exists W.dualCopairing ⟨φ, hφ⟩
state_before: case h.mpr
R : Type u_1
M : Type u_2
M' : Type ?u.1403652
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup M'
inst✝ : Module R M'
W : Submodule R M
φ : Dual R M
hφ : φ ∈ dualAnnihilator W
⊢ ∃ y, ↑(LinearMap.dualMap (mkQ W)) y = φ
Theorem: EuclideanDomain.dvd_lcm_right
File: Mathlib/Algebra/EuclideanDomain/Basic.lean

tactic: rw [lcm, hxy, div_zero]
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
x y : R
hxy : gcd x y = 0
⊢ y ∣ lcm x y

tactic: exact dvd_zero _
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
x y : R
hxy : gcd x y = 0
⊢ y ∣ 0

tactic: rw [← mul_assoc, mul_right_comm, ← hz]
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
x y : R
hxy : ¬gcd x y = 0
z : R
hz : x = gcd x y * z
⊢ gcd x y * (y * z) = x * y
Theorem: LieHom.id_comp
File: Mathlib/Algebra/Lie/Basic.lean

tactic: ext
state_before: R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
f : L₁ →ₗ⁅R⁆ L₂
⊢ comp id f = f

tactic: rfl
state_before: case h
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
f : L₁ →ₗ⁅R⁆ L₂
x✝ : L₁
⊢ ↑(comp id f) x✝ = ↑f x✝
Theorem: PGame.lt_or_equiv_or_gt_or_fuzzy
File: Mathlib/SetTheory/Game/PGame.lean

tactic: cases' le_or_gf x y with h₁ h₁ <;> cases' le_or_gf y x with h₂ h₂
state_before: x y : PGame
⊢ x < y ∨ (x ≈ y) ∨ y < x ∨ x ‖ y

tactic: right
state_before: case inl.inl
x y : PGame
h₁ : x ≤ y
h₂ : y ≤ x
⊢ x < y ∨ (x ≈ y) ∨ y < x ∨ x ‖ y

tactic: left
state_before: case inl.inl.h
x y : PGame
h₁ : x ≤ y
h₂ : y ≤ x
⊢ (x ≈ y) ∨ y < x ∨ x ‖ y

tactic: exact ⟨h₁, h₂⟩
state_before: case inl.inl.h.h
x y : PGame
h₁ : x ≤ y
h₂ : y ≤ x
⊢ x ≈ y

tactic: left
state_before: case inl.inr
x y : PGame
h₁ : x ≤ y
h₂ : x ⧏ y
⊢ x < y ∨ (x ≈ y) ∨ y < x ∨ x ‖ y

tactic: exact ⟨h₁, h₂⟩
state_before: case inl.inr.h
x y : PGame
h₁ : x ≤ y
h₂ : x ⧏ y
⊢ x < y

tactic: right
state_before: case inr.inl
x y : PGame
h₁ : y ⧏ x
h₂ : y ≤ x
⊢ x < y ∨ (x ≈ y) ∨ y < x ∨ x ‖ y

tactic: right
state_before: case inr.inl.h
x y : PGame
h₁ : y ⧏ x
h₂ : y ≤ x
⊢ (x ≈ y) ∨ y < x ∨ x ‖ y

tactic: left
state_before: case inr.inl.h.h
x y : PGame
h₁ : y ⧏ x
h₂ : y ≤ x
⊢ y < x ∨ x ‖ y

tactic: exact ⟨h₂, h₁⟩
state_before: case inr.inl.h.h.h
x y : PGame
h₁ : y ⧏ x
h₂ : y ≤ x
⊢ y < x

tactic: right
state_before: case inr.inr
x y : PGame
h₁ : y ⧏ x
h₂ : x ⧏ y
⊢ x < y ∨ (x ≈ y) ∨ y < x ∨ x ‖ y

tactic: right
state_before: case inr.inr.h
x y : PGame
h₁ : y ⧏ x
h₂ : x ⧏ y
⊢ (x ≈ y) ∨ y < x ∨ x ‖ y

tactic: right
state_before: case inr.inr.h.h
x y : PGame
h₁ : y ⧏ x
h₂ : x ⧏ y
⊢ y < x ∨ x ‖ y

tactic: exact ⟨h₂, h₁⟩
state_before: case inr.inr.h.h.h
x y : PGame
h₁ : y ⧏ x
h₂ : x ⧏ y
⊢ x ‖ y
Theorem: Real.Angle.toReal_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: constructor <;> linarith [pi_pos]
state_before: ⊢ -π < π / 2 ∧ π / 2 ≤ π
Theorem: List.join_reverse
File: Mathlib/Data/List/Join.lean

tactic: simpa [reverse_reverse, map_reverse] using congr_arg List.reverse (reverse_join L.reverse)
state_before: α : Type u_1
β : Type ?u.18738
L : List (List α)
⊢ join (reverse L) = reverse (join (map reverse L))
Theorem: CategoryTheory.rightAdjointMate_id
File: Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean

tactic: simp only [rightAdjointMate, MonoidalCategory.tensor_id, Category.id_comp,
  coevaluation_evaluation_assoc, Category.comp_id, Iso.inv_hom_id]
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
X : C
inst✝ : HasRightDual X
⊢ 𝟙 Xᘁ = 𝟙 Xᘁ
Theorem: bounded_iff_forall_norm_le'
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simpa only [Set.subset_def, mem_closedBall_one_iff] using bounded_iff_subset_ball (1 : E)
state_before: 𝓕 : Type ?u.98865
𝕜 : Type ?u.98868
α : Type ?u.98871
ι : Type ?u.98874
κ : Type ?u.98877
E : Type u_1
F : Type ?u.98883
G : Type ?u.98886
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
⊢ Bounded s ↔ ∃ C, ∀ (x : E), x ∈ s → ‖x‖ ≤ C
Theorem: Real.volume_univ
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

tactic: simp
state_before: ι : Type ?u.128288
inst✝ : Fintype ι
r : ℝ≥0
⊢ ↑r = ↑↑volume (Icc 0 ↑r)
Theorem: Matrix.smul_vec2
File: Mathlib/Data/Matrix/Notation.lean

tactic: rw [smul_cons, smul_cons, smul_empty]
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
R : Type u_1
inst✝ : SMul R α
x : R
a₀ a₁ : α
⊢ x • ![a₀, a₁] = ![x • a₀, x • a₁]
Theorem: PiLp.edist_equiv_symm_single_same
File: Mathlib/Analysis/NormedSpace/PiLp.lean

tactic: simp only [edist_nndist, nndist_equiv_symm_single_same p β i b₁ b₂]
state_before: p : ℝ≥0∞
𝕜 : Type ?u.494939
𝕜' : Type ?u.494942
ι : Type u_1
α : ι → Type ?u.494950
β : ι → Type u_2
inst✝⁹ : Fintype ι
inst✝⁸ : Fact (1 ≤ p)
inst✝⁷ : NormedField 𝕜
inst✝⁶ : NormedField 𝕜'
inst✝⁵ : (i : ι) → SeminormedAddCommGroup (β i)
inst✝⁴ : (i : ι) → NormedSpace 𝕜 (β i)
c : 𝕜
x y : PiLp p β
x' y' : (i : ι) → β i
i✝ : ι
ι' : Type ?u.495151
inst✝³ : Fintype ι'
E : Type ?u.495157
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : DecidableEq ι
i : ι
b₁ b₂ : β i
⊢ edist (↑(PiLp.equiv p β).symm (Pi.single i b₁)) (↑(PiLp.equiv p β).symm (Pi.single i b₂)) = edist b₁ b₂
Theorem: toDfinsupp_support
File: Mathlib/Data/Finsupp/ToDfinsupp.lean

tactic: ext
state_before: ι : Type u_1
R : Type ?u.2193
M : Type u_2
inst✝² : DecidableEq ι
inst✝¹ : Zero M
inst✝ : (m : M) → Decidable (m ≠ 0)
f : ι →₀ M
⊢ Dfinsupp.support (Finsupp.toDfinsupp f) = f.support

tactic: simp
state_before: case a
ι : Type u_1
R : Type ?u.2193
M : Type u_2
inst✝² : DecidableEq ι
inst✝¹ : Zero M
inst✝ : (m : M) → Decidable (m ≠ 0)
f : ι →₀ M
a✝ : ι
⊢ a✝ ∈ Dfinsupp.support (Finsupp.toDfinsupp f) ↔ a✝ ∈ f.support
Theorem: ContractingWith.edist_efixedPoint_le
File: Mathlib/Topology/MetricSpace/Contracting.lean

tactic: convert hf.apriori_edist_iterate_efixedPoint_le hx 0
state_before: α : Type u_1
inst✝ : EMetricSpace α
cs : CompleteSpace α
K : ℝ≥0
f : α → α
hf : ContractingWith K f
x : α
hx : edist x (f x) ≠ ⊤
⊢ edist x (efixedPoint f hf x hx) ≤ edist x (f x) / (1 - ↑K)

tactic: simp only [pow_zero, mul_one]
state_before: case h.e'_4.h.e'_5
α : Type u_1
inst✝ : EMetricSpace α
cs : CompleteSpace α
K : ℝ≥0
f : α → α
hf : ContractingWith K f
x : α
hx : edist x (f x) ≠ ⊤
⊢ edist x (f x) = edist x (f x) * ↑K ^ 0
Theorem: NNReal.rpow_nat_cast
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: simpa only [coe_rpow, coe_pow] using Real.rpow_nat_cast x n
state_before: x : ℝ≥0
n : ℕ
⊢ ↑(x ^ ↑n) = ↑(x ^ n)
Theorem: Int.floor_add_int
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [le_floor, ← sub_le_iff_le_add, ← sub_le_iff_le_add, le_floor, Int.cast_sub]
state_before: F : Type ?u.129440
α : Type u_1
β : Type ?u.129446
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a✝¹ a✝ : α
z a : ℤ
⊢ a ≤ ⌊a✝ + ↑z⌋ ↔ a ≤ ⌊a✝⌋ + z
Theorem: SimpleGraph.Subgraph.iSup_adj
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: simp [iSup]
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : Subgraph G
a b : V
f : ι → Subgraph G
⊢ Adj (⨆ (i : ι), f i) a b ↔ ∃ i, Adj (f i) a b
Theorem: Filter.Tendsto.max_left
File: Mathlib/Topology/Order/Basic.lean

tactic: simp_rw [max_comm _ a]
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderClosedTopology α
f g : β → α
l : Filter β
a : α
h : Tendsto f l (𝓝 a)
⊢ Tendsto (fun i => max (f i) a) l (𝓝 a)

tactic: exact h.max_right
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderClosedTopology α
f g : β → α
l : Filter β
a : α
h : Tendsto f l (𝓝 a)
⊢ Tendsto (fun i => max a (f i)) l (𝓝 a)
Theorem: Set.compl_section_ordSeparatingSet_mem_nhdsWithin_Iic
File: Mathlib/Topology/Algebra/Order/T5.lean

tactic: have hd' : Disjoint (ofDual ⁻¹' s) (closure <| ofDual ⁻¹' t) := hd
state_before: X : Type u_1
inst✝² : LinearOrder X
inst✝¹ : TopologicalSpace X
inst✝ : OrderTopology X
a b c : X
s t : Set X
hd : Disjoint s (closure t)
ha : a ∈ s
⊢ ordConnectedSection (ordSeparatingSet s t)ᶜ ∈ 𝓝[Iic a] a

tactic: have ha' : toDual a ∈ ofDual ⁻¹' s := ha
state_before: X : Type u_1
inst✝² : LinearOrder X
inst✝¹ : TopologicalSpace X
inst✝ : OrderTopology X
a b c : X
s t : Set X
hd : Disjoint s (closure t)
ha : a ∈ s
hd' : Disjoint (↑ofDual ⁻¹' s) (closure (↑ofDual ⁻¹' t))
⊢ ordConnectedSection (ordSeparatingSet s t)ᶜ ∈ 𝓝[Iic a] a

tactic: simpa only [dual_ordSeparatingSet, dual_ordConnectedSection] using
  compl_section_ordSeparatingSet_mem_nhdsWithin_Ici hd' ha'
state_before: X : Type u_1
inst✝² : LinearOrder X
inst✝¹ : TopologicalSpace X
inst✝ : OrderTopology X
a b c : X
s t : Set X
hd : Disjoint s (closure t)
ha : a ∈ s
hd' : Disjoint (↑ofDual ⁻¹' s) (closure (↑ofDual ⁻¹' t))
ha' : ↑toDual a ∈ ↑ofDual ⁻¹' s
⊢ ordConnectedSection (ordSeparatingSet s t)ᶜ ∈ 𝓝[Iic a] a
Theorem: CategoryTheory.Limits.limit.pre_eq
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: aesop_cat
state_before: J : Type u₁
inst✝⁶ : Category J
K : Type u₂
inst✝⁵ : Category K
C : Type u
inst✝⁴ : Category C
F : J ⥤ C
inst✝³ : HasLimit F
E : K ⥤ J
inst✝² : HasLimit (E ⋙ F)
L : Type u₃
inst✝¹ : Category L
D : L ⥤ K
inst✝ : HasLimit (D ⋙ E ⋙ F)
s : LimitCone (E ⋙ F)
t : LimitCone F
⊢ pre F E = (isoLimitCone t).hom ≫ IsLimit.lift s.isLimit (Cone.whisker E t.cone) ≫ (isoLimitCone s).inv
Theorem: LinearIsometryEquiv.norm_iteratedFDerivWithin_comp_right
File: Mathlib/Analysis/Calculus/ContDiff.lean

tactic: have : iteratedFDerivWithin 𝕜 i (f ∘ g) (g ⁻¹' s) x =
    (iteratedFDerivWithin 𝕜 i f s (g x)).compContinuousLinearMap fun _ => g :=
  g.toContinuousLinearEquiv.iteratedFDerivWithin_comp_right f hs hx i
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type ?u.537850
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x✝ x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
g : G ≃ₗᵢ[𝕜] E
f : E → F
hs : UniqueDiffOn 𝕜 s
x : G
hx : ↑g x ∈ s
i : ℕ
⊢ ‖iteratedFDerivWithin 𝕜 i (f ∘ ↑g) (↑g ⁻¹' s) x‖ = ‖iteratedFDerivWithin 𝕜 i f s (↑g x)‖

tactic: rw [this, ContinuousMultilinearMap.norm_compContinuous_linearIsometryEquiv]
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type ?u.537850
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x✝ x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
g : G ≃ₗᵢ[𝕜] E
f : E → F
hs : UniqueDiffOn 𝕜 s
x : G
hx : ↑g x ∈ s
i : ℕ
this :
  iteratedFDerivWithin 𝕜 i (f ∘ ↑g) (↑g ⁻¹' s) x =
    ContinuousMultilinearMap.compContinuousLinearMap (iteratedFDerivWithin 𝕜 i f s (↑g x)) fun x =>
      ↑(ContinuousLinearEquiv.mk g.toLinearEquiv)
⊢ ‖iteratedFDerivWithin 𝕜 i (f ∘ ↑g) (↑g ⁻¹' s) x‖ = ‖iteratedFDerivWithin 𝕜 i f s (↑g x)‖
Theorem: Int.fdiv_eq_ediv_of_dvd
File: Std/Data/Int/DivMod.lean

tactic: if bz : b = 0 then simp [bz] else
rw [mul_fdiv_cancel_left _ bz, mul_ediv_cancel_left _ bz]
state_before: b c : Int
⊢ fdiv (b * c) b = b * c / b

tactic: simp [bz]
state_before: b c : Int
bz : b = 0
⊢ fdiv (b * c) b = b * c / b

tactic: rw [mul_fdiv_cancel_left _ bz, mul_ediv_cancel_left _ bz]
state_before: b c : Int
bz : ¬b = 0
⊢ fdiv (b * c) b = b * c / b
Theorem: Equiv.Perm.cycleType_extendDomain
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

tactic: induction g using cycle_induction_on with
| base_one => rw [extendDomain_one, cycleType_one, cycleType_one]
| base_cycles σ hσ =>
  rw [(hσ.extendDomain f).cycleType, hσ.cycleType, card_support_extend_domain]
| induction_disjoint σ τ hd _ hσ hτ =>
  rw [hd.cycleType, ← extendDomain_mul, (hd.extendDomain f).cycleType, hσ, hτ]
state_before: α : Type u_2
inst✝⁴ : Fintype α
inst✝³ : DecidableEq α
β : Type u_1
inst✝² : Fintype β
inst✝¹ : DecidableEq β
p : β → Prop
inst✝ : DecidablePred p
f : α ≃ Subtype p
g : Perm α
⊢ cycleType (extendDomain g f) = cycleType g

tactic: rw [extendDomain_one, cycleType_one, cycleType_one]
state_before: case base_one
α : Type u_2
inst✝⁴ : Fintype α
inst✝³ : DecidableEq α
β : Type u_1
inst✝² : Fintype β
inst✝¹ : DecidableEq β
p : β → Prop
inst✝ : DecidablePred p
f : α ≃ Subtype p
⊢ cycleType (extendDomain 1 f) = cycleType 1

tactic: rw [(hσ.extendDomain f).cycleType, hσ.cycleType, card_support_extend_domain]
state_before: case base_cycles
α : Type u_2
inst✝⁴ : Fintype α
inst✝³ : DecidableEq α
β : Type u_1
inst✝² : Fintype β
inst✝¹ : DecidableEq β
p : β → Prop
inst✝ : DecidablePred p
f : α ≃ Subtype p
σ : Perm α
hσ : IsCycle σ
⊢ cycleType (extendDomain σ f) = cycleType σ

tactic: rw [hd.cycleType, ← extendDomain_mul, (hd.extendDomain f).cycleType, hσ, hτ]
state_before: case induction_disjoint
α : Type u_2
inst✝⁴ : Fintype α
inst✝³ : DecidableEq α
β : Type u_1
inst✝² : Fintype β
inst✝¹ : DecidableEq β
p : β → Prop
inst✝ : DecidablePred p
f : α ≃ Subtype p
σ τ : Perm α
hd : Disjoint σ τ
a✝ : IsCycle σ
hσ : cycleType (extendDomain σ f) = cycleType σ
hτ : cycleType (extendDomain τ f) = cycleType τ
⊢ cycleType (extendDomain (σ * τ) f) = cycleType (σ * τ)
Theorem: Submonoid.LocalizationMap.map_map
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: rw [← @map_comp_map M _ S N _ P _ f g T hy Q _ k A _ U R _ j l hl]
state_before: M : Type u_6
inst✝⁵ : CommMonoid M
S : Submonoid M
N : Type u_4
inst✝⁴ : CommMonoid N
P : Type u_3
inst✝³ : CommMonoid P
f : LocalizationMap S N
g : M →* P
hg : ∀ (y : { x // x ∈ S }), IsUnit (↑g ↑y)
T : Submonoid P
hy : ∀ (y : { x // x ∈ S }), ↑g ↑y ∈ T
Q : Type u_5
inst✝² : CommMonoid Q
k : LocalizationMap T Q
A : Type u_1
inst✝¹ : CommMonoid A
U : Submonoid A
R : Type u_2
inst✝ : CommMonoid R
j : LocalizationMap U R
l : P →* A
hl : ∀ (w : { x // x ∈ T }), ↑l ↑w ∈ U
x : N
⊢ ↑(map k hl j) (↑(map f hy k) x) = ↑(map f (_ : ∀ (x : { x // x ∈ S }), ↑(MonoidHom.comp l g) ↑x ∈ U) j) x

tactic: simp only [MonoidHom.coe_comp, comp_apply]
state_before: M : Type u_6
inst✝⁵ : CommMonoid M
S : Submonoid M
N : Type u_4
inst✝⁴ : CommMonoid N
P : Type u_3
inst✝³ : CommMonoid P
f : LocalizationMap S N
g : M →* P
hg : ∀ (y : { x // x ∈ S }), IsUnit (↑g ↑y)
T : Submonoid P
hy : ∀ (y : { x // x ∈ S }), ↑g ↑y ∈ T
Q : Type u_5
inst✝² : CommMonoid Q
k : LocalizationMap T Q
A : Type u_1
inst✝¹ : CommMonoid A
U : Submonoid A
R : Type u_2
inst✝ : CommMonoid R
j : LocalizationMap U R
l : P →* A
hl : ∀ (w : { x // x ∈ T }), ↑l ↑w ∈ U
x : N
⊢ ↑(map k hl j) (↑(map f hy k) x) = ↑(MonoidHom.comp (map k hl j) (map f hy k)) x
Theorem: Ideal.map_mk_eq_bot_of_le
File: Mathlib/RingTheory/Ideal/QuotientOperations.lean

tactic: rw [map_eq_bot_iff_le_ker, mk_ker]
state_before: R : Type u
S : Type v
F : Type w
inst✝¹ : CommRing R
inst✝ : CommRing S
I J : Ideal R
h : I ≤ J
⊢ map (Quotient.mk J) I = ⊥

tactic: exact h
state_before: R : Type u
S : Type v
F : Type w
inst✝¹ : CommRing R
inst✝ : CommRing S
I J : Ideal R
h : I ≤ J
⊢ I ≤ J
Theorem: Function.Periodic.const_inv_smul₀
File: Mathlib/Algebra/Periodic.lean

tactic: simpa only [inv_inv] using h.const_smul₀ a⁻¹
state_before: α : Type u_1
β : Type u_3
γ : Type u_2
f g : α → β
c c₁ c₂ x : α
inst✝² : AddCommMonoid α
inst✝¹ : DivisionSemiring γ
inst✝ : Module γ α
h : Periodic f c
a : γ
⊢ Periodic (fun x => f (a⁻¹ • x)) (a • c)
Theorem: Nat.succ_mul
File: src/lean/Init/Data/Nat/Basic.lean

tactic: induction m with
| zero => rfl
| succ m ih => rw [mul_succ, add_succ, ih, mul_succ, add_succ, Nat.add_right_comm]
state_before: n m : Nat
⊢ succ n * m = n * m + m

tactic: rfl
state_before: case zero
n : Nat
⊢ succ n * zero = n * zero + zero

tactic: rw [mul_succ, add_succ, ih, mul_succ, add_succ, Nat.add_right_comm]
state_before: case succ
n m : Nat
ih : succ n * m = n * m + m
⊢ succ n * succ m = n * succ m + succ m
Theorem: Set.preimage_iUnion
File: Mathlib/Data/Set/Lattice.lean

tactic: simp [preimage]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.218372
ι : Sort u_3
ι' : Sort ?u.218378
ι₂ : Sort ?u.218381
κ : ι → Sort ?u.218386
κ₁ : ι → Sort ?u.218391
κ₂ : ι → Sort ?u.218396
κ' : ι' → Sort ?u.218401
f : α → β
s : ι → Set β
⊢ ∀ (x : α), (x ∈ f ⁻¹' ⋃ (i : ι), s i) ↔ x ∈ ⋃ (i : ι), f ⁻¹' s i
Theorem: Rat.abs_def
File: Mathlib/Data/Rat/Order.lean

tactic: cases' le_total q 0 with hq hq
state_before: a b c q : ℚ
⊢ abs q = ↑(Int.natAbs q.num) /. ↑q.den

tactic: rw [abs_of_nonpos hq]
state_before: case inl
a b c q : ℚ
hq : q ≤ 0
⊢ abs q = ↑(Int.natAbs q.num) /. ↑q.den

tactic: rw [← @num_den q, ← divInt_zero_one, Rat.le_def (Int.coe_nat_pos.2 q.pos) zero_lt_one, mul_one,
  zero_mul] at hq
state_before: case inl
a b c q : ℚ
hq : q ≤ 0
⊢ -q = ↑(Int.natAbs q.num) /. ↑q.den

tactic: rw [Int.ofNat_natAbs_of_nonpos hq, ← neg_def, num_den]
state_before: case inl
a b c q : ℚ
hq : q.num ≤ 0
⊢ -q = ↑(Int.natAbs q.num) /. ↑q.den

tactic: rw [abs_of_nonneg hq]
state_before: case inr
a b c q : ℚ
hq : 0 ≤ q
⊢ abs q = ↑(Int.natAbs q.num) /. ↑q.den

tactic: rw [← @num_den q, ← divInt_zero_one, Rat.le_def zero_lt_one (Int.coe_nat_pos.2 q.pos), mul_one,
  zero_mul] at hq
state_before: case inr
a b c q : ℚ
hq : 0 ≤ q
⊢ q = ↑(Int.natAbs q.num) /. ↑q.den

tactic: rw [Int.natAbs_of_nonneg hq, num_den]
state_before: case inr
a b c q : ℚ
hq : 0 ≤ q.num
⊢ q = ↑(Int.natAbs q.num) /. ↑q.den