tasksource/leandojo huggingface dataset:
Theorem: Monotone.of_map_inf
File: Mathlib/Order/Lattice.lean

tactic: rw [← h, inf_eq_left.2 hxy]
state_before: α : Type u
β : Type v
inst✝¹ : SemilatticeInf α
inst✝ : SemilatticeInf β
f : α → β
h : ∀ (x y : α), f (x ⊓ y) = f x ⊓ f y
x y : α
hxy : x ≤ y
⊢ f x ⊓ f y = f x
Theorem: Path.Homotopy.continuous_reflTransSymmAux
File: Mathlib/AlgebraicTopology/FundamentalGroupoid/Basic.lean

tactic: refine' continuous_if_le _ _ (Continuous.continuousOn _) (Continuous.continuousOn _) _
state_before: X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
⊢ Continuous reflTransSymmAux

tactic: intro x hx
state_before: case refine'_5
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
⊢ ∀ (x : ↑I × ↑I), ↑x.snd = 1 / 2 → ↑x.fst * 2 * ↑x.snd = ↑x.fst * (2 - 2 * ↑x.snd)

tactic: rw [hx, mul_assoc]
state_before: case refine'_5
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
x : ↑I × ↑I
hx : ↑x.snd = 1 / 2
⊢ ↑x.fst * 2 * ↑x.snd = ↑x.fst * (2 - 2 * ↑x.snd)

tactic: norm_num
state_before: case refine'_5
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
x : ↑I × ↑I
hx : ↑x.snd = 1 / 2
⊢ ↑x.fst * (2 * (1 / 2)) = ↑x.fst * (2 - 2 * (1 / 2))

tactic: continuity
state_before: case refine'_1
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
⊢ Continuous fun x => ↑x.snd

tactic: continuity
state_before: case refine'_2
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
⊢ Continuous fun x => 1 / 2

tactic: continuity
state_before: case refine'_3
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
⊢ Continuous fun x => ↑x.fst * 2 * ↑x.snd

tactic: continuity
state_before: case refine'_4
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
⊢ Continuous fun x => ↑x.fst * (2 - 2 * ↑x.snd)
Theorem: LinearOrderedField.inducedMap_rat
File: Mathlib/Algebra/Order/CompleteField.lean

tactic: refine csSup_eq_of_forall_le_of_forall_lt_exists_gt
  (cutMap_nonempty β (q : α)) (fun x h => ?_) fun w h => ?_
state_before: F : Type ?u.17063
α : Type u_2
β : Type u_1
γ : Type ?u.17072
inst✝³ : LinearOrderedField α
inst✝² : ConditionallyCompleteLinearOrderedField β
inst✝¹ : ConditionallyCompleteLinearOrderedField γ
inst✝ : Archimedean α
q : ℚ
⊢ inducedMap α β ↑q = ↑q

tactic: rw [cutMap_coe] at h
state_before: case refine_1
F : Type ?u.17063
α : Type u_2
β : Type u_1
γ : Type ?u.17072
inst✝³ : LinearOrderedField α
inst✝² : ConditionallyCompleteLinearOrderedField β
inst✝¹ : ConditionallyCompleteLinearOrderedField γ
inst✝ : Archimedean α
q : ℚ
x : β
h : x ∈ cutMap β ↑q
⊢ x ≤ ↑q

tactic: obtain ⟨r, h, rfl⟩ := h
state_before: case refine_1
F : Type ?u.17063
α : Type u_2
β : Type u_1
γ : Type ?u.17072
inst✝³ : LinearOrderedField α
inst✝² : ConditionallyCompleteLinearOrderedField β
inst✝¹ : ConditionallyCompleteLinearOrderedField γ
inst✝ : Archimedean α
q : ℚ
x : β
h : x ∈ Rat.cast '' {r | ↑r < ↑q}
⊢ x ≤ ↑q

tactic: exact le_of_lt h
state_before: case refine_1.intro.intro
F : Type ?u.17063
α : Type u_2
β : Type u_1
γ : Type ?u.17072
inst✝³ : LinearOrderedField α
inst✝² : ConditionallyCompleteLinearOrderedField β
inst✝¹ : ConditionallyCompleteLinearOrderedField γ
inst✝ : Archimedean α
q r : ℚ
h : r ∈ {r | ↑r < ↑q}
⊢ ↑r ≤ ↑q

tactic: obtain ⟨q', hwq, hq⟩ := exists_rat_btwn h
state_before: case refine_2
F : Type ?u.17063
α : Type u_2
β : Type u_1
γ : Type ?u.17072
inst✝³ : LinearOrderedField α
inst✝² : ConditionallyCompleteLinearOrderedField β
inst✝¹ : ConditionallyCompleteLinearOrderedField γ
inst✝ : Archimedean α
q : ℚ
w : β
h : w < ↑q
⊢ ∃ a, a ∈ cutMap β ↑q ∧ w < a

tactic: rw [cutMap_coe]
state_before: case refine_2.intro.intro
F : Type ?u.17063
α : Type u_2
β : Type u_1
γ : Type ?u.17072
inst✝³ : LinearOrderedField α
inst✝² : ConditionallyCompleteLinearOrderedField β
inst✝¹ : ConditionallyCompleteLinearOrderedField γ
inst✝ : Archimedean α
q : ℚ
w : β
h : w < ↑q
q' : ℚ
hwq : w < ↑q'
hq : ↑q' < ↑q
⊢ ∃ a, a ∈ cutMap β ↑q ∧ w < a

tactic: exact ⟨q', ⟨_, hq, rfl⟩, hwq⟩
state_before: case refine_2.intro.intro
F : Type ?u.17063
α : Type u_2
β : Type u_1
γ : Type ?u.17072
inst✝³ : LinearOrderedField α
inst✝² : ConditionallyCompleteLinearOrderedField β
inst✝¹ : ConditionallyCompleteLinearOrderedField γ
inst✝ : Archimedean α
q : ℚ
w : β
h : w < ↑q
q' : ℚ
hwq : w < ↑q'
hq : ↑q' < ↑q
⊢ ∃ a, a ∈ Rat.cast '' {r | ↑r < ↑q} ∧ w < a
Theorem: Fin.prod_congr'
File: Mathlib/Algebra/BigOperators/Fin.lean

tactic: subst h
state_before: α : Type ?u.64969
β : Type ?u.64972
M : Type u_1
inst✝ : CommMonoid M
a b : ℕ
f : Fin b → M
h : a = b
⊢ ∏ i : Fin a, f (↑(cast h) i) = ∏ i : Fin b, f i

tactic: congr
state_before: α : Type ?u.64969
β : Type ?u.64972
M : Type u_1
inst✝ : CommMonoid M
a : ℕ
f : Fin a → M
⊢ ∏ i : Fin a, f (↑(cast (_ : a = a)) i) = ∏ i : Fin a, f i
Theorem: zpow_sub_one₀
File: Mathlib/Algebra/GroupWithZero/Power.lean

tactic: rw [mul_assoc, mul_inv_cancel ha, mul_one]
state_before: G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
ha : a ≠ 0
n : ℤ
⊢ a ^ (n - 1) = a ^ (n - 1) * a * a⁻¹

tactic: rw [← zpow_add_one₀ ha, sub_add_cancel]
state_before: G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
ha : a ≠ 0
n : ℤ
⊢ a ^ (n - 1) * a * a⁻¹ = a ^ n * a⁻¹
Theorem: separated_iff_t2
File: Mathlib/Topology/UniformSpace/Separation.lean

tactic: constructor <;> intro h
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
⊢ SeparatedSpace α ↔ T2Space α

tactic: rw [t2_iff_isClosed_diagonal, ← show 𝓢 α = diagonal α from h.1]
state_before: case mp
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
h : SeparatedSpace α
⊢ T2Space α

tactic: exact isClosed_separationRel
state_before: case mp
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
h : SeparatedSpace α
⊢ IsClosed (𝓢 α)

tactic: rw [separated_def']
state_before: case mpr
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
h : T2Space α
⊢ SeparatedSpace α

tactic: intro x y hxy
state_before: case mpr
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
h : T2Space α
⊢ ∀ (x y : α), x ≠ y → ∃ r, r ∈ 𝓤 α ∧ ¬(x, y) ∈ r

tactic: rcases t2_separation hxy with ⟨u, v, uo, -, hx, hy, h⟩
state_before: case mpr
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
h : T2Space α
x y : α
hxy : x ≠ y
⊢ ∃ r, r ∈ 𝓤 α ∧ ¬(x, y) ∈ r

tactic: rcases isOpen_iff_ball_subset.1 uo x hx with ⟨r, hrU, hr⟩
state_before: case mpr.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
h✝ : T2Space α
x y : α
hxy : x ≠ y
u v : Set α
uo : IsOpen u
hx : x ∈ u
hy : y ∈ v
h : Disjoint u v
⊢ ∃ r, r ∈ 𝓤 α ∧ ¬(x, y) ∈ r

tactic: exact ⟨r, hrU, fun H => h.le_bot ⟨hr H, hy⟩⟩
state_before: case mpr.intro.intro.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
h✝ : T2Space α
x y : α
hxy : x ≠ y
u v : Set α
uo : IsOpen u
hx : x ∈ u
hy : y ∈ v
h : Disjoint u v
r : Set (α × α)
hrU : r ∈ 𝓤 α
hr : ball x r ⊆ u
⊢ ∃ r, r ∈ 𝓤 α ∧ ¬(x, y) ∈ r
Theorem: directedOn_pair'
File: Mathlib/Order/Directed.lean

tactic: rw [Set.pair_comm]
state_before: α : Type u
β : Type v
ι : Sort w
r r' s : α → α → Prop
h : Reflexive r
a b : α
hab : r a b
⊢ DirectedOn r {b, a}

tactic: apply directedOn_pair h hab
state_before: α : Type u
β : Type v
ι : Sort w
r r' s : α → α → Prop
h : Reflexive r
a b : α
hab : r a b
⊢ DirectedOn r {a, b}
Theorem: Set.Icc_diff_right
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: simp [lt_iff_le_and_ne, and_assoc]
state_before: α : Type u_1
β : Type ?u.34759
inst✝ : PartialOrder α
a b c x : α
⊢ x ∈ Icc a b \ {b} ↔ x ∈ Ico a b
Theorem: AlgebraicTopology.inclusionOfMooreComplexMap_f
File: Mathlib/AlgebraicTopology/AlternatingFaceMapComplex.lean

tactic: dsimp only [inclusionOfMooreComplexMap]
state_before: C : Type ?u.247870
inst✝³ : Category C
inst✝² : Preadditive C
A : Type u_2
inst✝¹ : Category A
inst✝ : Abelian A
X : SimplicialObject A
n : ℕ
⊢ HomologicalComplex.Hom.f (inclusionOfMooreComplexMap X) n = arrow (NormalizedMooreComplex.objX X n)

tactic: exact ChainComplex.ofHom_f _ _ _ _ _ _ _ _ n
state_before: C : Type ?u.247870
inst✝³ : Category C
inst✝² : Preadditive C
A : Type u_2
inst✝¹ : Category A
inst✝ : Abelian A
X : SimplicialObject A
n : ℕ
⊢ HomologicalComplex.Hom.f
      (id
        (ChainComplex.ofHom (fun n => underlying.obj (NormalizedMooreComplex.objX X n)) (NormalizedMooreComplex.objD X)
          (_ : ∀ (n : ℕ), NormalizedMooreComplex.objD X (n + 1) ≫ NormalizedMooreComplex.objD X n = 0)
          (fun n => X.obj [n].op) (AlternatingFaceMapComplex.objD X)
          (_ : ∀ (n : ℕ), AlternatingFaceMapComplex.objD X (n + 1) ≫ AlternatingFaceMapComplex.objD X n = 0)
          (fun n => arrow (NormalizedMooreComplex.objX X n))
          (_ :
            ∀ (i : ℕ),
              arrow (NormalizedMooreComplex.objX X (i + 1)) ≫ AlternatingFaceMapComplex.objD X i =
                NormalizedMooreComplex.objD X i ≫ arrow (NormalizedMooreComplex.objX X i))))
      n =
    arrow (NormalizedMooreComplex.objX X n)
Theorem: GaloisInsertion.l_biInf_u
File: Mathlib/Order/GaloisConnection.lean

tactic: simp only [iInf_subtype', gi.l_iInf_u]
state_before: α : Type u
β : Type v
γ : Type w
ι✝ : Sort x
κ : ι✝ → Sort ?u.41283
a a₁ a₂ : α
b b₁ b₂ : β
l : α → β
u : β → α
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
gi : GaloisInsertion l u
ι : Sort x
p : ι → Prop
f : (i : ι) → p i → β
⊢ l (⨅ (i : ι) (hi : p i), u (f i hi)) = ⨅ (i : ι) (hi : p i), f i hi
Theorem: FiniteDimensional.finrank_pi
File: Mathlib/LinearAlgebra/FreeModule/Finite/Rank.lean

tactic: simp [finrank]
state_before: R : Type u
M : Type v
N : Type w
inst✝¹⁰ : Ring R
inst✝⁹ : StrongRankCondition R
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
inst✝⁶ : Module.Free R M
inst✝⁵ : Module.Finite R M
inst✝⁴ : AddCommGroup N
inst✝³ : Module R N
inst✝² : Module.Free R N
inst✝¹ : Module.Finite R N
ι : Type v
inst✝ : Fintype ι
⊢ finrank R (ι → R) = card ι
Theorem: Finset.le_card_of_inj_on_range
File: Mathlib/Data/Finset/Card.lean

tactic: simpa only [mem_range]
state_before: α : Type u_1
β : Type ?u.26322
s t : Finset α
f✝ : α → β
n : ℕ
f : ℕ → α
hf : ∀ (i : ℕ), i < n → f i ∈ s
f_inj : ∀ (i : ℕ), i < n → ∀ (j : ℕ), j < n → f i = f j → i = j
⊢ ∀ (a : ℕ), a ∈ range n → f a ∈ s

tactic: simpa only [mem_range]
state_before: α : Type u_1
β : Type ?u.26322
s t : Finset α
f✝ : α → β
n : ℕ
f : ℕ → α
hf : ∀ (i : ℕ), i < n → f i ∈ s
f_inj : ∀ (i : ℕ), i < n → ∀ (j : ℕ), j < n → f i = f j → i = j
⊢ ∀ (a₁ : ℕ), a₁ ∈ range n → ∀ (a₂ : ℕ), a₂ ∈ range n → f a₁ = f a₂ → a₁ = a₂
Theorem: ContinuousLinearEquiv.comp_hasFDerivAt_iff
File: Mathlib/Analysis/Calculus/FDeriv/Equiv.lean

tactic: simp_rw [← hasFDerivWithinAt_univ, iso.comp_hasFDerivWithinAt_iff]
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_3
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_4
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_2
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.109770
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x✝ : E
s t : Set E
L L₁ L₂ : Filter E
iso : E ≃L[𝕜] F
f : G → E
x : G
f' : G →L[𝕜] E
⊢ HasFDerivAt (↑iso ∘ f) (comp (↑iso) f') x ↔ HasFDerivAt f f' x
Theorem: Ordinal.mul_eq_right_iff_opow_omega_dvd
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: cases' eq_zero_or_pos a with ha ha
state_before: a b : Ordinal
⊢ a * b = b ↔ a ^ ω ∣ b

tactic: refine' ⟨fun hab => _, fun h => _⟩
state_before: case inr
a b : Ordinal
ha : 0 < a
⊢ a * b = b ↔ a ^ ω ∣ b

tactic: cases' h with c hc
state_before: case inr.refine'_2
a b : Ordinal
ha : 0 < a
h : a ^ ω ∣ b
⊢ a * b = b

tactic: rw [hc, ← mul_assoc, ← opow_one_add, one_add_omega]
state_before: case inr.refine'_2.intro
a b : Ordinal
ha : 0 < a
c : Ordinal
hc : b = a ^ ω * c
⊢ a * b = b

tactic: rw [ha, zero_mul, zero_opow omega_ne_zero, zero_dvd_iff]
state_before: case inl
a b : Ordinal
ha : a = 0
⊢ a * b = b ↔ a ^ ω ∣ b

tactic: exact eq_comm
state_before: case inl
a b : Ordinal
ha : a = 0
⊢ 0 = b ↔ b = 0

tactic: rw [dvd_iff_mod_eq_zero]
state_before: case inr.refine'_1
a b : Ordinal
ha : 0 < a
hab : a * b = b
⊢ a ^ ω ∣ b

tactic: rw [← div_add_mod b (a^omega), mul_add, ← mul_assoc, ← opow_one_add, one_add_omega,
  add_left_cancel] at hab
state_before: case inr.refine'_1
a b : Ordinal
ha : 0 < a
hab : a * b = b
⊢ b % a ^ ω = 0

tactic: cases' eq_zero_or_opow_omega_le_of_mul_eq_right hab with hab hab
state_before: case inr.refine'_1
a b : Ordinal
ha : 0 < a
hab : a * (b % a ^ ω) = b % a ^ ω
⊢ b % a ^ ω = 0

tactic: refine' (not_lt_of_le hab (mod_lt b (opow_ne_zero omega _))).elim
state_before: case inr.refine'_1.inr
a b : Ordinal
ha : 0 < a
hab✝ : a * (b % a ^ ω) = b % a ^ ω
hab : a ^ ω ≤ b % a ^ ω
⊢ b % a ^ ω = 0

tactic: rwa [← Ordinal.pos_iff_ne_zero]
state_before: case inr.refine'_1.inr
a b : Ordinal
ha : 0 < a
hab✝ : a * (b % a ^ ω) = b % a ^ ω
hab : a ^ ω ≤ b % a ^ ω
⊢ a ≠ 0

tactic: exact hab
state_before: case inr.refine'_1.inl
a b : Ordinal
ha : 0 < a
hab✝ : a * (b % a ^ ω) = b % a ^ ω
hab : b % a ^ ω = 0
⊢ b % a ^ ω = 0
Theorem: Set.pair_eq_pair_iff
File: Mathlib/Data/Set/Basic.lean

tactic: simp only [Set.Subset.antisymm_iff, Set.insert_subset, Set.mem_insert_iff, Set.mem_singleton_iff,
  Set.singleton_subset_iff]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
x y z w : α
⊢ {x, y} = {z, w} ↔ x = z ∧ y = w ∨ x = w ∧ y = z

tactic: constructor
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
x y z w : α
⊢ ((x = z ∨ x = w) ∧ (y = z ∨ y = w)) ∧ (z = x ∨ z = y) ∧ (w = x ∨ w = y) ↔ x = z ∧ y = w ∨ x = w ∧ y = z

tactic: rintro ⟨⟨rfl | rfl, rfl | rfl⟩, ⟨h₁, h₂⟩⟩ <;> simp [h₁, h₂] at * <;> simp [h₁, h₂]
state_before: case mp
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
x y z w : α
⊢ ((x = z ∨ x = w) ∧ (y = z ∨ y = w)) ∧ (z = x ∨ z = y) ∧ (w = x ∨ w = y) → x = z ∧ y = w ∨ x = w ∧ y = z

tactic: rintro (⟨rfl, rfl⟩ | ⟨rfl, rfl⟩) <;> simp
state_before: case mpr
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
x y z w : α
⊢ x = z ∧ y = w ∨ x = w ∧ y = z → ((x = z ∨ x = w) ∧ (y = z ∨ y = w)) ∧ (z = x ∨ z = y) ∧ (w = x ∨ w = y)
Theorem: CategoryTheory.isCoseparator_prod_of_isCoseparator_left
File: Mathlib/CategoryTheory/Generator.lean

tactic: simp
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
inst✝¹ : HasZeroMorphisms C
G H : C
inst✝ : HasBinaryProduct G H
hG : IsCoseparator G
⊢ {G} ⊆ {G, H}
Theorem: iUnion_compactCovering
File: Mathlib/Topology/SubsetProperties.lean

tactic: rw [compactCovering, iUnion_accumulate]
state_before: α : Type u
β : Type v
ι : Type ?u.155649
π : ι → Type ?u.155654
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
s t : Set α
inst✝ : SigmaCompactSpace α
⊢ (⋃ (n : ℕ), compactCovering α n) = univ

tactic: exact (Classical.choose_spec SigmaCompactSpace.exists_compact_covering).2
state_before: α : Type u
β : Type v
ι : Type ?u.155649
π : ι → Type ?u.155654
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
s t : Set α
inst✝ : SigmaCompactSpace α
⊢ (⋃ (x : ℕ), Exists.choose (_ : ∃ K, (∀ (n : ℕ), IsCompact (K n)) ∧ (⋃ (n : ℕ), K n) = univ) x) = univ
Theorem: Localization.Away.mk_eq_monoidOf_mk'
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: simp
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type ?u.3319938
inst✝¹ : CommMonoid N
P : Type ?u.3319944
inst✝ : CommMonoid P
f : Submonoid.LocalizationMap S N
x : M
⊢ mk = Submonoid.LocalizationMap.mk' (monoidOf x)
Theorem: Polynomial.degree_eq_iff_natDegree_eq_of_pos
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: constructor
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n : ℕ
hn : 0 < n
⊢ degree p = ↑n ↔ natDegree p = n

tactic: intro H
state_before: case mp
R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n : ℕ
hn : 0 < n
⊢ degree p = ↑n → natDegree p = n

tactic: rwa [← degree_eq_iff_natDegree_eq]
state_before: case mp
R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n : ℕ
hn : 0 < n
H : degree p = ↑n
⊢ natDegree p = n

tactic: rintro rfl
state_before: case mp
R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n : ℕ
hn : 0 < n
H : degree p = ↑n
⊢ p ≠ 0

tactic: rw [degree_zero] at H
state_before: case mp
R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
hn : 0 < n
H : degree 0 = ↑n
⊢ False

tactic: exact Option.noConfusion H
state_before: case mp
R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
hn : 0 < n
H : ⊥ = ↑n
⊢ False

tactic: intro H
state_before: case mpr
R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n : ℕ
hn : 0 < n
⊢ natDegree p = n → degree p = ↑n

tactic: rwa [degree_eq_iff_natDegree_eq]
state_before: case mpr
R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n : ℕ
hn : 0 < n
H : natDegree p = n
⊢ degree p = ↑n

tactic: rintro rfl
state_before: case mpr
R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n : ℕ
hn : 0 < n
H : natDegree p = n
⊢ p ≠ 0

tactic: rw [natDegree_zero] at H
state_before: case mpr
R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
hn : 0 < n
H : natDegree 0 = n
⊢ False

tactic: rw [H] at hn
state_before: case mpr
R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
hn : 0 < n
H : 0 = n
⊢ False

tactic: exact lt_irrefl _ hn
state_before: case mpr
R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
hn : n < n
H : 0 = n
⊢ False
Theorem: CategoryTheory.Functor.map_eq_zero_iff
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Zero.lean

tactic: rintro rfl
state_before: C : Type u₁
inst✝⁵ : Category C
D : Type u₂
inst✝⁴ : Category D
inst✝³ : HasZeroMorphisms C
inst✝² : HasZeroMorphisms D
F : C ⥤ D
inst✝¹ : PreservesZeroMorphisms F
inst✝ : Faithful F
X Y : C
f : X ⟶ Y
⊢ f = 0 → F.map f = 0

tactic: exact F.map_zero _ _
state_before: C : Type u₁
inst✝⁵ : Category C
D : Type u₂
inst✝⁴ : Category D
inst✝³ : HasZeroMorphisms C
inst✝² : HasZeroMorphisms D
F : C ⥤ D
inst✝¹ : PreservesZeroMorphisms F
inst✝ : Faithful F
X Y : C
⊢ F.map 0 = 0
Theorem: Finset.insert_val'
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [dedup_cons, dedup_eq_self]
state_before: α : Type u_1
β : Type ?u.103025
γ : Type ?u.103028
inst✝ : DecidableEq α
s✝ t u v : Finset α
a✝ b a : α
s : Finset α
⊢ (insert a s).val = dedup (a ::ₘ s.val)

tactic: rfl
state_before: α : Type u_1
β : Type ?u.103025
γ : Type ?u.103028
inst✝ : DecidableEq α
s✝ t u v : Finset α
a✝ b a : α
s : Finset α
⊢ (insert a s).val = ndinsert a s.val
Theorem: PicardLindelof.FunSpace.vComp_apply_coe
File: Mathlib/Analysis/ODE/PicardLindelof.lean

tactic: simp only [vComp, proj_coe]
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
f : FunSpace v
t : ↑(Icc v.tMin v.tMax)
⊢ vComp f ↑t = PicardLindelof.toFun v (↑t) (toFun f t)
Theorem: Fermat42.neg_of_minimal
File: Mathlib/NumberTheory/Fermat4.lean

tactic: rintro ⟨⟨ha, hb, heq⟩, h2⟩
state_before: a b c : ℤ
⊢ Minimal a b c → Minimal a b (-c)

tactic: constructor
state_before: case intro.intro.intro
a b c : ℤ
h2 : ∀ (a1 b1 c1 : ℤ), Fermat42 a1 b1 c1 → Int.natAbs c ≤ Int.natAbs c1
ha : a ≠ 0
hb : b ≠ 0
heq : a ^ 4 + b ^ 4 = c ^ 2
⊢ Minimal a b (-c)

tactic: rwa [Int.natAbs_neg c]
state_before: case intro.intro.intro.right
a b c : ℤ
h2 : ∀ (a1 b1 c1 : ℤ), Fermat42 a1 b1 c1 → Int.natAbs c ≤ Int.natAbs c1
ha : a ≠ 0
hb : b ≠ 0
heq : a ^ 4 + b ^ 4 = c ^ 2
⊢ ∀ (a1 b1 c1 : ℤ), Fermat42 a1 b1 c1 → Int.natAbs (-c) ≤ Int.natAbs c1

tactic: apply And.intro ha (And.intro hb _)
state_before: case intro.intro.intro.left
a b c : ℤ
h2 : ∀ (a1 b1 c1 : ℤ), Fermat42 a1 b1 c1 → Int.natAbs c ≤ Int.natAbs c1
ha : a ≠ 0
hb : b ≠ 0
heq : a ^ 4 + b ^ 4 = c ^ 2
⊢ Fermat42 a b (-c)

tactic: rw [heq]
state_before: a b c : ℤ
h2 : ∀ (a1 b1 c1 : ℤ), Fermat42 a1 b1 c1 → Int.natAbs c ≤ Int.natAbs c1
ha : a ≠ 0
hb : b ≠ 0
heq : a ^ 4 + b ^ 4 = c ^ 2
⊢ a ^ 4 + b ^ 4 = (-c) ^ 2

tactic: exact (neg_sq c).symm
state_before: a b c : ℤ
h2 : ∀ (a1 b1 c1 : ℤ), Fermat42 a1 b1 c1 → Int.natAbs c ≤ Int.natAbs c1
ha : a ≠ 0
hb : b ≠ 0
heq : a ^ 4 + b ^ 4 = c ^ 2
⊢ c ^ 2 = (-c) ^ 2
Theorem: Int.fract_sub_nat
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [fract]
state_before: F : Type ?u.149099
α : Type u_1
β : Type ?u.149105
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a : α
n : ℕ
⊢ fract (a - ↑n) = fract a

tactic: simp
state_before: F : Type ?u.149099
α : Type u_1
β : Type ?u.149105
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a : α
n : ℕ
⊢ a - ↑n - ↑⌊a - ↑n⌋ = fract a
Theorem: Nat.bit1_eq_bit1
File: Mathlib/Data/Nat/Bits.lean

tactic: subst h
state_before: n✝ m n : ℕ
h : m = n
⊢ bit1 m = bit1 n

tactic: rfl
state_before: n m : ℕ
⊢ bit1 m = bit1 m
Theorem: one_le_inv
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rwa [le_inv (@zero_lt_one α _ _ _ _ _) h₁, inv_one]
state_before: ι : Type ?u.54083
α : Type u_1
β : Type ?u.54089
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
h₁ : 0 < a
h₂ : a ≤ 1
⊢ 1 ≤ a⁻¹
Theorem: AddSubgroup.dense_of_no_min
File: Mathlib/Topology/Algebra/Order/Archimedean.lean

tactic: refine S.dense_of_not_isolated_zero fun ε ε0 => ?_
state_before: G : Type u_1
inst✝³ : LinearOrderedAddCommGroup G
inst✝² : TopologicalSpace G
inst✝¹ : OrderTopology G
inst✝ : Archimedean G
S : AddSubgroup G
hbot : S ≠ ⊥
H : ¬∃ a, IsLeast {g | g ∈ S ∧ 0 < g} a
⊢ Dense ↑S

tactic: contrapose! H
state_before: G : Type u_1
inst✝³ : LinearOrderedAddCommGroup G
inst✝² : TopologicalSpace G
inst✝¹ : OrderTopology G
inst✝ : Archimedean G
S : AddSubgroup G
hbot : S ≠ ⊥
H : ¬∃ a, IsLeast {g | g ∈ S ∧ 0 < g} a
ε : G
ε0 : ε > 0
⊢ ∃ g, g ∈ S ∧ g ∈ Ioo 0 ε

tactic: exact exists_isLeast_pos hbot ε0 (disjoint_left.2 H)
state_before: G : Type u_1
inst✝³ : LinearOrderedAddCommGroup G
inst✝² : TopologicalSpace G
inst✝¹ : OrderTopology G
inst✝ : Archimedean G
S : AddSubgroup G
hbot : S ≠ ⊥
ε : G
ε0 : ε > 0
H : ∀ (g : G), g ∈ S → ¬g ∈ Ioo 0 ε
⊢ ∃ a, IsLeast {g | g ∈ S ∧ 0 < g} a
Theorem: Finpartition.botIsUniform
File: Mathlib/Combinatorics/SimpleGraph/Regularity/Uniform.lean

tactic: rw [Finpartition.IsUniform, Finpartition.card_bot, nonUniforms_bot _ hε, Finset.card_empty,
  Nat.cast_zero]
state_before: α : Type u_2
𝕜 : Type u_1
inst✝² : LinearOrderedField 𝕜
inst✝¹ : DecidableEq α
A : Finset α
P : Finpartition A
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
hε : 0 < ε
⊢ IsUniform ⊥ G ε

tactic: exact mul_nonneg (Nat.cast_nonneg _) hε.le
state_before: α : Type u_2
𝕜 : Type u_1
inst✝² : LinearOrderedField 𝕜
inst✝¹ : DecidableEq α
A : Finset α
P : Finpartition A
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
hε : 0 < ε
⊢ 0 ≤ ↑(card A * (card A - 1)) * ε