tasksource/leandojo huggingface dataset:
Theorem: Real.sign_apply_eq
File: Mathlib/Data/Real/Sign.lean

tactic: obtain hn | rfl | hp := lt_trichotomy r (0 : ℝ)
state_before: r : ℝ
⊢ sign r = -1 ∨ sign r = 0 ∨ sign r = 1

tactic: exact Or.inl <| sign_of_neg hn
state_before: case inl
r : ℝ
hn : r < 0
⊢ sign r = -1 ∨ sign r = 0 ∨ sign r = 1

tactic: exact Or.inr <| Or.inl <| sign_zero
state_before: case inr.inl

⊢ sign 0 = -1 ∨ sign 0 = 0 ∨ sign 0 = 1

tactic: exact Or.inr <| Or.inr <| sign_of_pos hp
state_before: case inr.inr
r : ℝ
hp : 0 < r
⊢ sign r = -1 ∨ sign r = 0 ∨ sign r = 1
Theorem: Option.bind_eq_none'
File: Mathlib/Data/Option/Basic.lean

tactic: simp only [eq_none_iff_forall_not_mem, mem_def, bind_eq_some, not_exists, not_and]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.2567
δ : Type ?u.2570
o : Option α
f : α → Option β
⊢ Option.bind o f = none ↔ ∀ (b : β) (a : α), a ∈ o → ¬b ∈ f a
Theorem: Complex.continuousWithinAt_arg_of_re_neg_of_im_zero
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: have : arg =ᶠ[𝓝[{ z : ℂ | 0 ≤ z.im }] z] fun x => Real.arcsin ((-x).im / abs x) + π := by
  have : ∀ᶠ x : ℂ in 𝓝 z, x.re < 0 := continuous_re.tendsto z (gt_mem_nhds hre)
  filter_upwards [self_mem_nhdsWithin (s := { z : ℂ | 0 ≤ z.im }),
    mem_nhdsWithin_of_mem_nhds this] with _ him hre
  rw [arg, if_neg hre.not_le, if_pos him]
state_before: x z✝ z : ℂ
hre : z.re < 0
him : z.im = 0
⊢ ContinuousWithinAt arg {z | 0 ≤ z.im} z

tactic: refine' ContinuousWithinAt.congr_of_eventuallyEq _ this _
state_before: x z✝ z : ℂ
hre : z.re < 0
him : z.im = 0
this : arg =ᶠ[𝓝[{z | 0 ≤ z.im}] z] fun x => arcsin ((-x).im / ↑abs x) + π
⊢ ContinuousWithinAt arg {z | 0 ≤ z.im} z

tactic: have : ∀ᶠ x : ℂ in 𝓝 z, x.re < 0 := continuous_re.tendsto z (gt_mem_nhds hre)
state_before: x z✝ z : ℂ
hre : z.re < 0
him : z.im = 0
⊢ arg =ᶠ[𝓝[{z | 0 ≤ z.im}] z] fun x => arcsin ((-x).im / ↑abs x) + π

tactic: filter_upwards [self_mem_nhdsWithin (s := { z : ℂ | 0 ≤ z.im }),
  mem_nhdsWithin_of_mem_nhds this] with _ him hre
state_before: x z✝ z : ℂ
hre : z.re < 0
him : z.im = 0
this : ∀ᶠ (x : ℂ) in 𝓝 z, x.re < 0
⊢ arg =ᶠ[𝓝[{z | 0 ≤ z.im}] z] fun x => arcsin ((-x).im / ↑abs x) + π

tactic: rw [arg, if_neg hre.not_le, if_pos him]
state_before: case h
x z✝ z : ℂ
hre✝ : z.re < 0
him✝ : z.im = 0
this : ∀ᶠ (x : ℂ) in 𝓝 z, x.re < 0
a✝ : ℂ
him : 0 ≤ a✝.im
hre : a✝.re < 0
⊢ arg a✝ = arcsin ((-a✝).im / ↑abs a✝) + π

tactic: refine'
  (Real.continuousAt_arcsin.comp_continuousWithinAt
        ((continuous_im.continuousAt.comp_continuousWithinAt continuousWithinAt_neg).div
          continuous_abs.continuousWithinAt _)).add
    tendsto_const_nhds
state_before: case refine'_1
x z✝ z : ℂ
hre : z.re < 0
him : z.im = 0
this : arg =ᶠ[𝓝[{z | 0 ≤ z.im}] z] fun x => arcsin ((-x).im / ↑abs x) + π
⊢ ContinuousWithinAt (fun x => arcsin ((-x).im / ↑abs x) + π) {z | 0 ≤ z.im} z

tactic: lift z to ℝ using him
state_before: case refine'_1
x z✝ z : ℂ
hre : z.re < 0
him : z.im = 0
this : arg =ᶠ[𝓝[{z | 0 ≤ z.im}] z] fun x => arcsin ((-x).im / ↑abs x) + π
⊢ ↑abs z ≠ 0

tactic: simpa using hre.ne
state_before: case refine'_1.intro
x z✝ : ℂ
z : ℝ
hre : (↑z).re < 0
this : arg =ᶠ[𝓝[{z | 0 ≤ z.im}] ↑z] fun x => arcsin ((-x).im / ↑abs x) + π
⊢ ↑abs ↑z ≠ 0

tactic: rw [arg, if_neg hre.not_le, if_pos him.ge]
state_before: case refine'_2
x z✝ z : ℂ
hre : z.re < 0
him : z.im = 0
this : arg =ᶠ[𝓝[{z | 0 ≤ z.im}] z] fun x => arcsin ((-x).im / ↑abs x) + π
⊢ arg z = arcsin ((-z).im / ↑abs z) + π
Theorem: Prod.mk_wcovby_mk_iff_left
File: Mathlib/Order/Cover.lean

tactic: refine' ⟨Wcovby.fst, (And.imp mk_le_mk_iff_left.2) fun h c h₁ h₂ => _⟩
state_before: α : Type u_2
β : Type u_1
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
⊢ (a₁, b) ⩿ (a₂, b) ↔ a₁ ⩿ a₂

tactic: have : c.2 = b := h₂.le.2.antisymm h₁.le.2
state_before: α : Type u_2
β : Type u_1
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
h : ∀ ⦃c : α⦄, a₁ < c → ¬c < a₂
c : α × β
h₁ : (a₁, b) < c
h₂ : c < (a₂, b)
⊢ False

tactic: rw [← @Prod.mk.eta _ _ c, this, mk_lt_mk_iff_left] at h₁ h₂
state_before: α : Type u_2
β : Type u_1
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
h : ∀ ⦃c : α⦄, a₁ < c → ¬c < a₂
c : α × β
h₁ : (a₁, b) < c
h₂ : c < (a₂, b)
this : c.snd = b
⊢ False

tactic: exact h h₁ h₂
state_before: α : Type u_2
β : Type u_1
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
h : ∀ ⦃c : α⦄, a₁ < c → ¬c < a₂
c : α × β
h₁ : a₁ < c.fst
h₂ : c.fst < a₂
this : c.snd = b
⊢ False
Theorem: card_derangements_fin_eq_numDerangements
File: Mathlib/Combinatorics/Derangements/Finite.lean

tactic: induction' n using Nat.strong_induction_on with n hyp
state_before: α : Type ?u.13112
inst✝¹ : DecidableEq α
inst✝ : Fintype α
n : ℕ
⊢ card ↑(derangements (Fin n)) = numDerangements n

tactic: rcases n with _ | _ | n
state_before: case h
α : Type ?u.13112
inst✝¹ : DecidableEq α
inst✝ : Fintype α
n : ℕ
hyp : ∀ (m : ℕ), m < n → card ↑(derangements (Fin m)) = numDerangements m
⊢ card ↑(derangements (Fin n)) = numDerangements n

tactic: rw [numDerangements_add_two, card_derangements_fin_add_two, mul_add,
  hyp _ (Nat.lt_add_of_pos_right zero_lt_two), hyp _ (lt_add_one _)]
state_before: case h.succ.succ
α : Type ?u.13112
inst✝¹ : DecidableEq α
inst✝ : Fintype α
n : ℕ
hyp : ∀ (m : ℕ), m < Nat.succ (Nat.succ n) → card ↑(derangements (Fin m)) = numDerangements m
⊢ card ↑(derangements (Fin (Nat.succ (Nat.succ n)))) = numDerangements (Nat.succ (Nat.succ n))

tactic: convert_to card ↑{ f : Perm (Fin 0) | ∀ (x : Fin 0), f x ≠ x }  = _ using 2
state_before: case h.zero
α : Type ?u.13112
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hyp : ∀ (m : ℕ), m < Nat.zero → card ↑(derangements (Fin m)) = numDerangements m
⊢ card ↑(derangements (Fin Nat.zero)) = numDerangements Nat.zero

tactic: rfl
state_before: case h.zero
α : Type ?u.13112
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hyp : ∀ (m : ℕ), m < Nat.zero → card ↑(derangements (Fin m)) = numDerangements m
⊢ card ↑{f | ∀ (x : Fin 0), ↑f x ≠ x} = numDerangements Nat.zero

tactic: convert_to card ↑{ f : Perm (Fin 1) | ∀ (x : Fin 1), f x ≠ x }  = _ using 2
state_before: case h.succ.zero
α : Type ?u.13112
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hyp : ∀ (m : ℕ), m < Nat.succ Nat.zero → card ↑(derangements (Fin m)) = numDerangements m
⊢ card ↑(derangements (Fin (Nat.succ Nat.zero))) = numDerangements (Nat.succ Nat.zero)

tactic: rfl
state_before: case h.succ.zero
α : Type ?u.13112
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hyp : ∀ (m : ℕ), m < Nat.succ Nat.zero → card ↑(derangements (Fin m)) = numDerangements m
⊢ card ↑{f | ∀ (x : Fin 1), ↑f x ≠ x} = numDerangements (Nat.succ Nat.zero)
Theorem: lowerClosure_infs
File: Mathlib/Data/Set/Sups.lean

tactic: ext a
state_before: α : Type u_1
inst✝ : SemilatticeInf α
s t : Set α
⊢ lowerClosure (s ⊼ t) = lowerClosure s ⊓ lowerClosure t

tactic: simp only [SetLike.mem_coe, mem_lowerClosure, Set.mem_infs, exists_and_left, exists_prop,
  LowerSet.coe_sup, Set.mem_inter_iff]
state_before: case a.h
α : Type u_1
inst✝ : SemilatticeInf α
s t : Set α
a : α
⊢ a ∈ ↑(lowerClosure (s ⊼ t)) ↔ a ∈ ↑(lowerClosure s ⊓ lowerClosure t)

tactic: constructor
state_before: case a.h
α : Type u_1
inst✝ : SemilatticeInf α
s t : Set α
a : α
⊢ (∃ a_1, (∃ a, a ∈ s ∧ ∃ b, b ∈ t ∧ a ⊓ b = a_1) ∧ a ≤ a_1) ↔ a ∈ lowerClosure s ⊓ lowerClosure t

tactic: rintro ⟨_, ⟨b, hb, c, hc, rfl⟩, ha⟩
state_before: case a.h.mp
α : Type u_1
inst✝ : SemilatticeInf α
s t : Set α
a : α
⊢ (∃ a_1, (∃ a, a ∈ s ∧ ∃ b, b ∈ t ∧ a ⊓ b = a_1) ∧ a ≤ a_1) → a ∈ lowerClosure s ⊓ lowerClosure t

tactic: exact ⟨⟨b, hb, ha.trans inf_le_left⟩, c, hc, ha.trans inf_le_right⟩
state_before: case a.h.mp.intro.intro.intro.intro.intro.intro
α : Type u_1
inst✝ : SemilatticeInf α
s t : Set α
a b : α
hb : b ∈ s
c : α
hc : c ∈ t
ha : a ≤ b ⊓ c
⊢ a ∈ lowerClosure s ⊓ lowerClosure t

tactic: rintro ⟨⟨b, hb, hab⟩, c, hc, hac⟩
state_before: case a.h.mpr
α : Type u_1
inst✝ : SemilatticeInf α
s t : Set α
a : α
⊢ a ∈ lowerClosure s ⊓ lowerClosure t → ∃ a_2, (∃ a, a ∈ s ∧ ∃ b, b ∈ t ∧ a ⊓ b = a_2) ∧ a ≤ a_2

tactic: exact ⟨_, ⟨b, hb, c, hc, rfl⟩, le_inf hab hac⟩
state_before: case a.h.mpr.intro.intro.intro.intro.intro
α : Type u_1
inst✝ : SemilatticeInf α
s t : Set α
a b : α
hb : b ∈ s
hab : a ≤ b
c : α
hc : c ∈ t
hac : a ≤ c
⊢ ∃ a_1, (∃ a, a ∈ s ∧ ∃ b, b ∈ t ∧ a ⊓ b = a_1) ∧ a ≤ a_1
Theorem: Nat.mul_div_le_mul_div_assoc
File: Mathlib/Data/Nat/Basic.lean

tactic: simp [hc0]
state_before: m n k a b c : ℕ
hc0 : c = 0
⊢ a * (b / c) ≤ a * b / c

tactic: rw [mul_assoc]
state_before: m n k a b c : ℕ
hc0 : ¬c = 0
⊢ a * (b / c) * c ≤ a * b

tactic: exact Nat.mul_le_mul_left _ (Nat.div_mul_le_self _ _)
state_before: m n k a b c : ℕ
hc0 : ¬c = 0
⊢ a * (b / c * c) ≤ a * b
Theorem: tendsto_Ioi_atBot
File: Mathlib/Topology/Order/Basic.lean

tactic: rw [← comap_coe_Ioi_nhdsWithin_Ioi, tendsto_comap_iff]
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a b : α
s : Set α
l : Filter β
f✝ : α → β
f : β → ↑(Ioi a)
⊢ Tendsto f l atBot ↔ Tendsto (fun x => ↑(f x)) l (𝓝[Ioi a] a)

tactic: rfl
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a b : α
s : Set α
l : Filter β
f✝ : α → β
f : β → ↑(Ioi a)
⊢ Tendsto (Subtype.val ∘ f) l (𝓝[Ioi a] a) ↔ Tendsto (fun x => ↑(f x)) l (𝓝[Ioi a] a)
Theorem: StrictConvexOn.add_convexOn
File: Mathlib/Analysis/Convex/Function.lean

tactic: rw [smul_add, smul_add, add_add_add_comm]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.276818
α : Type ?u.276821
β : Type u_3
ι : Type ?u.276827
inst✝⁵ : OrderedSemiring 𝕜
inst✝⁴ : AddCommMonoid E
inst✝³ : AddCommMonoid F
inst✝² : OrderedCancelAddCommMonoid β
inst✝¹ : SMul 𝕜 E
inst✝ : DistribMulAction 𝕜 β
s : Set E
f g : E → β
hf : StrictConvexOn 𝕜 s f
hg : ConvexOn 𝕜 s g
x : E
hx : x ∈ s
y : E
hy : y ∈ s
hxy : x ≠ y
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ a • f x + b • f y + (a • g x + b • g y) = a • (f x + g x) + b • (f y + g y)
Theorem: Metric.preimage_mul_right_closedBall
File: Mathlib/Topology/MetricSpace/IsometricSMul.lean

tactic: rw [div_eq_mul_inv]
state_before: M : Type u
G : Type v
X : Type w
inst✝⁵ : PseudoMetricSpace X
inst✝⁴ : Group G
inst✝³ : MulAction G X
inst✝² : IsometricSMul G X
inst✝¹ : PseudoMetricSpace G
inst✝ : IsometricSMul Gᵐᵒᵖ G
a b : G
r : ℝ
⊢ (fun x => x * a) ⁻¹' closedBall b r = closedBall (b / a) r

tactic: exact preimage_smul_closedBall (MulOpposite.op a) b r
state_before: M : Type u
G : Type v
X : Type w
inst✝⁵ : PseudoMetricSpace X
inst✝⁴ : Group G
inst✝³ : MulAction G X
inst✝² : IsometricSMul G X
inst✝¹ : PseudoMetricSpace G
inst✝ : IsometricSMul Gᵐᵒᵖ G
a b : G
r : ℝ
⊢ (fun x => x * a) ⁻¹' closedBall b r = closedBall (b * a⁻¹) r
Theorem: Set.biUnion_iUnion
File: Mathlib/Data/Set/Lattice.lean

tactic: simp [@iUnion_comm _ ι]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.169471
ι : Sort u_3
ι' : Sort ?u.169477
ι₂ : Sort ?u.169480
κ : ι → Sort ?u.169485
κ₁ : ι → Sort ?u.169490
κ₂ : ι → Sort ?u.169495
κ' : ι' → Sort ?u.169500
s : ι → Set α
t : α → Set β
⊢ (⋃ (x : α) (_ : x ∈ ⋃ (i : ι), s i), t x) = ⋃ (i : ι) (x : α) (_ : x ∈ s i), t x
Theorem: MeasureTheory.MeasurePreserving.preErgodic_conjugate_iff
File: Mathlib/Dynamics/Ergodic/Ergodic.lean

tactic: refine' ⟨fun hf => preErgodic_of_preErgodic_conjugate (h.symm e) hf _,
    fun hf => preErgodic_of_preErgodic_conjugate h hf _⟩
state_before: α : Type u_1
m : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
β : Type u_2
m' : MeasurableSpace β
μ' : Measure β
s' : Set β
g : α → β
e : α ≃ᵐ β
h : MeasurePreserving ↑e
⊢ PreErgodic (↑e ∘ f ∘ ↑(MeasurableEquiv.symm e)) ↔ PreErgodic f

tactic: change (e.symm ∘ e) ∘ f ∘ e.symm = f ∘ e.symm
state_before: case refine'_1
α : Type u_1
m : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
β : Type u_2
m' : MeasurableSpace β
μ' : Measure β
s' : Set β
g : α → β
e : α ≃ᵐ β
h : MeasurePreserving ↑e
hf : PreErgodic (↑e ∘ f ∘ ↑(MeasurableEquiv.symm e))
⊢ ↑(MeasurableEquiv.symm e) ∘ ↑e ∘ f ∘ ↑(MeasurableEquiv.symm e) = f ∘ ↑(MeasurableEquiv.symm e)

tactic: rw [MeasurableEquiv.symm_comp_self, comp.left_id]
state_before: case refine'_1
α : Type u_1
m : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
β : Type u_2
m' : MeasurableSpace β
μ' : Measure β
s' : Set β
g : α → β
e : α ≃ᵐ β
h : MeasurePreserving ↑e
hf : PreErgodic (↑e ∘ f ∘ ↑(MeasurableEquiv.symm e))
⊢ (↑(MeasurableEquiv.symm e) ∘ ↑e) ∘ f ∘ ↑(MeasurableEquiv.symm e) = f ∘ ↑(MeasurableEquiv.symm e)

tactic: change e ∘ f = e ∘ f ∘ e.symm ∘ e
state_before: case refine'_2
α : Type u_1
m : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
β : Type u_2
m' : MeasurableSpace β
μ' : Measure β
s' : Set β
g : α → β
e : α ≃ᵐ β
h : MeasurePreserving ↑e
hf : PreErgodic f
⊢ ↑e ∘ f = (↑e ∘ f ∘ ↑(MeasurableEquiv.symm e)) ∘ ↑e

tactic: rw [MeasurableEquiv.symm_comp_self, comp.right_id]
state_before: case refine'_2
α : Type u_1
m : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
β : Type u_2
m' : MeasurableSpace β
μ' : Measure β
s' : Set β
g : α → β
e : α ≃ᵐ β
h : MeasurePreserving ↑e
hf : PreErgodic f
⊢ ↑e ∘ f = ↑e ∘ f ∘ ↑(MeasurableEquiv.symm e) ∘ ↑e
Theorem: isEmpty_Prop
File: Mathlib/Logic/IsEmpty.lean

tactic: simp only [← not_nonempty_iff, nonempty_Prop]
state_before: α : Sort ?u.2122
β : Sort ?u.2125
γ : Sort ?u.2128
p : Prop
⊢ IsEmpty p ↔ ¬p
Theorem: minpoly.mem_range_of_degree_eq_one
File: Mathlib/FieldTheory/Minpoly/Basic.lean

tactic: have h : IsIntegral A x := by
  by_contra h
  rw [eq_zero h, degree_zero, ← WithBot.coe_one] at hx
  exact ne_of_lt (show ⊥ < ↑1 from WithBot.bot_lt_coe 1) hx
state_before: A : Type u_1
B : Type u_2
B' : Type ?u.31272
inst✝⁴ : CommRing A
inst✝³ : Ring B
inst✝² : Ring B'
inst✝¹ : Algebra A B
inst✝ : Algebra A B'
x : B
hx : degree (minpoly A x) = 1
⊢ x ∈ RingHom.range (algebraMap A B)

tactic: have key := minpoly.aeval A x
state_before: A : Type u_1
B : Type u_2
B' : Type ?u.31272
inst✝⁴ : CommRing A
inst✝³ : Ring B
inst✝² : Ring B'
inst✝¹ : Algebra A B
inst✝ : Algebra A B'
x : B
hx : degree (minpoly A x) = 1
h : IsIntegral A x
⊢ x ∈ RingHom.range (algebraMap A B)

tactic: rw [eq_X_add_C_of_degree_eq_one hx, (minpoly.monic h).leadingCoeff, C_1, one_mul, aeval_add,
  aeval_C, aeval_X, ← eq_neg_iff_add_eq_zero, ← RingHom.map_neg] at key
state_before: A : Type u_1
B : Type u_2
B' : Type ?u.31272
inst✝⁴ : CommRing A
inst✝³ : Ring B
inst✝² : Ring B'
inst✝¹ : Algebra A B
inst✝ : Algebra A B'
x : B
hx : degree (minpoly A x) = 1
h : IsIntegral A x
key : ↑(Polynomial.aeval x) (minpoly A x) = 0
⊢ x ∈ RingHom.range (algebraMap A B)

tactic: exact ⟨-(minpoly A x).coeff 0, key.symm⟩
state_before: A : Type u_1
B : Type u_2
B' : Type ?u.31272
inst✝⁴ : CommRing A
inst✝³ : Ring B
inst✝² : Ring B'
inst✝¹ : Algebra A B
inst✝ : Algebra A B'
x : B
hx : degree (minpoly A x) = 1
h : IsIntegral A x
key : x = ↑(algebraMap A B) (-coeff (minpoly A x) 0)
⊢ x ∈ RingHom.range (algebraMap A B)

tactic: by_contra h
state_before: A : Type u_1
B : Type u_2
B' : Type ?u.31272
inst✝⁴ : CommRing A
inst✝³ : Ring B
inst✝² : Ring B'
inst✝¹ : Algebra A B
inst✝ : Algebra A B'
x : B
hx : degree (minpoly A x) = 1
⊢ IsIntegral A x

tactic: rw [eq_zero h, degree_zero, ← WithBot.coe_one] at hx
state_before: A : Type u_1
B : Type u_2
B' : Type ?u.31272
inst✝⁴ : CommRing A
inst✝³ : Ring B
inst✝² : Ring B'
inst✝¹ : Algebra A B
inst✝ : Algebra A B'
x : B
hx : degree (minpoly A x) = 1
h : ¬IsIntegral A x
⊢ False

tactic: exact ne_of_lt (show ⊥ < ↑1 from WithBot.bot_lt_coe 1) hx
state_before: A : Type u_1
B : Type u_2
B' : Type ?u.31272
inst✝⁴ : CommRing A
inst✝³ : Ring B
inst✝² : Ring B'
inst✝¹ : Algebra A B
inst✝ : Algebra A B'
x : B
hx : ⊥ = ↑1
h : ¬IsIntegral A x
⊢ False
Theorem: Fin.pred_add_one
File: Mathlib/Data/Fin/Basic.lean

tactic: exact
(add_one_pos _ (lt_iff_val_lt_val.2 h))
state_before: n m : ℕ
i : Fin (n + 2)
h : ↑i < n + 1
⊢ 0 < i + 1

tactic: rw [ext_iff, coe_pred, coe_castLT, val_add, val_one, mod_eq_of_lt, add_tsub_cancel_right]
state_before: n m : ℕ
i : Fin (n + 2)
h : ↑i < n + 1
⊢ pred (i + 1) (_ : i + 1 ≠ 0) = castLT i h

tactic: exact add_lt_add_right h 1
state_before: n m : ℕ
i : Fin (n + 2)
h : ↑i < n + 1
⊢ ↑i + 1 < n + 1 + 1
Theorem: exists_eq_right
File: Std/Logic.lean

tactic: exact fun a => And.comm
state_before: α : Sort u_1
p q : α → Prop
b : Prop
a' : α
⊢ ∀ (a : α), p a ∧ a = a' ↔ a = a' ∧ p a
Theorem: Std.BinomialHeapImp.HeapNode.WellFormed.toHeap
File: Std/Data/BinomialHeap.lean

tactic: rw [toHeap, rankTR_eq]
state_before: α : Type u_1
le : α → α → Bool
a : α
n : Nat
s : HeapNode α
h : WellFormed le a s n
⊢ Heap.WellFormed le 0 (HeapNode.toHeap s)

tactic: exact go h trivial
state_before: α : Type u_1
le : α → α → Bool
a : α
n : Nat
s : HeapNode α
h : WellFormed le a s n
⊢ Heap.WellFormed le 0 (HeapNode.toHeap.go s (rank s) Heap.nil)

tactic: rw [← h'.rank_eq] at h
state_before: α : Type u_1
le : α → α → Bool
a✝ : α
n✝ : Nat
s✝ : HeapNode α
h✝ : WellFormed le a✝ s✝ n✝
res : Heap α
a : α
c s : HeapNode α
n : Nat
left✝ : ∀ [inst : TotalBLE le], le a✝ a = true
h : WellFormed le a c n
h' : WellFormed le a✝ s n
hr : Heap.WellFormed le (rank (node a c s)) res
⊢ WellFormed le a c (rank (node a c s) - 1)

tactic: exact h
state_before: α : Type u_1
le : α → α → Bool
a✝ : α
n✝ : Nat
s✝ : HeapNode α
h✝ : WellFormed le a✝ s✝ n✝
res : Heap α
a : α
c s : HeapNode α
n : Nat
left✝ : ∀ [inst : TotalBLE le], le a✝ a = true
h : WellFormed le a c (rank s)
h' : WellFormed le a✝ s n
hr : Heap.WellFormed le (rank (node a c s)) res
⊢ WellFormed le a c (rank (node a c s) - 1)
Theorem: AddMonoidAlgebra.sup_support_mul_le
File: Mathlib/Algebra/MonoidAlgebra/Degree.lean

tactic: refine' (Finset.sup_mono <| support_mul _ _).trans _
state_before: R : Type u_3
A : Type u_2
T : Type ?u.14182
B : Type u_1
ι : Type ?u.14188
inst✝¹¹ : SemilatticeSup B
inst✝¹⁰ : OrderBot B
inst✝⁹ : SemilatticeInf T
inst✝⁸ : OrderTop T
inst✝⁷ : Semiring R
inst✝⁶ : Add A
inst✝⁵ : Add B
inst✝⁴ : Add T
inst✝³ : CovariantClass B B (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝² : CovariantClass B B (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : CovariantClass T T (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass T T (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
degb : A → B
degbm : ∀ {a b : A}, degb (a + b) ≤ degb a + degb b
f g : AddMonoidAlgebra R A
⊢ Finset.sup (f * g).support degb ≤ Finset.sup f.support degb + Finset.sup g.support degb

tactic: simp_rw [Finset.sup_biUnion, Finset.sup_singleton]
state_before: R : Type u_3
A : Type u_2
T : Type ?u.14182
B : Type u_1
ι : Type ?u.14188
inst✝¹¹ : SemilatticeSup B
inst✝¹⁰ : OrderBot B
inst✝⁹ : SemilatticeInf T
inst✝⁸ : OrderTop T
inst✝⁷ : Semiring R
inst✝⁶ : Add A
inst✝⁵ : Add B
inst✝⁴ : Add T
inst✝³ : CovariantClass B B (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝² : CovariantClass B B (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : CovariantClass T T (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass T T (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
degb : A → B
degbm : ∀ {a b : A}, degb (a + b) ≤ degb a + degb b
f g : AddMonoidAlgebra R A
⊢ Finset.sup (Finset.biUnion f.support fun a₁ => Finset.biUnion g.support fun a₂ => {a₁ + a₂}) degb ≤
    Finset.sup f.support degb + Finset.sup g.support degb

tactic: refine' Finset.sup_le fun fd fds => Finset.sup_le fun gd gds => degbm.trans <| add_le_add _ _ <;>
  exact Finset.le_sup ‹_›
state_before: R : Type u_3
A : Type u_2
T : Type ?u.14182
B : Type u_1
ι : Type ?u.14188
inst✝¹¹ : SemilatticeSup B
inst✝¹⁰ : OrderBot B
inst✝⁹ : SemilatticeInf T
inst✝⁸ : OrderTop T
inst✝⁷ : Semiring R
inst✝⁶ : Add A
inst✝⁵ : Add B
inst✝⁴ : Add T
inst✝³ : CovariantClass B B (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝² : CovariantClass B B (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : CovariantClass T T (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass T T (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
degb : A → B
degbm : ∀ {a b : A}, degb (a + b) ≤ degb a + degb b
f g : AddMonoidAlgebra R A
⊢ (Finset.sup f.support fun x => Finset.sup g.support fun x_1 => degb (x + x_1)) ≤
    Finset.sup f.support degb + Finset.sup g.support degb
Theorem: InnerProductGeometry.cos_eq_zero_iff_angle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean

tactic: rw [← cos_pi_div_two]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
⊢ cos (angle x y) = 0 ↔ angle x y = π / 2

tactic: apply injOn_cos.eq_iff ⟨angle_nonneg x y, angle_le_pi x y⟩
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
⊢ cos (angle x y) = cos (π / 2) ↔ angle x y = π / 2

tactic: constructor <;> linarith [pi_pos]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
⊢ π / 2 ∈ Icc 0 π
Theorem: List.range_succ_eq_map
File: Std/Data/List/Lemmas.lean

tactic: rw [range_eq_range', range_eq_range', range', Nat.add_comm, ← map_add_range']
state_before: n : Nat
⊢ range (n + 1) = 0 :: map succ (range n)

tactic: congr
state_before: n : Nat
⊢ 0 :: map (fun x => 1 + x) (range' 0 n) = 0 :: map succ (range' 0 n)

tactic: exact funext one_add
state_before: case e_tail.e_f
n : Nat
⊢ (fun x => 1 + x) = succ
Theorem: DiscreteQuotient.isClopen_setOf_rel
File: Mathlib/Topology/DiscreteQuotient.lean

tactic: rw [← fiber_eq]
state_before: α : Type ?u.6073
X : Type u_1
Y : Type ?u.6079
Z : Type ?u.6082
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
S : DiscreteQuotient X
x : X
⊢ IsClopen (setOf (Setoid.Rel S.toSetoid x))

tactic: apply isClopen_preimage
state_before: α : Type ?u.6073
X : Type u_1
Y : Type ?u.6079
Z : Type ?u.6082
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
S : DiscreteQuotient X
x : X
⊢ IsClopen (proj S ⁻¹' {proj S x})
Theorem: AffineBasis.toMatrix_mul_toMatrix
File: Mathlib/LinearAlgebra/AffineSpace/Matrix.lean

tactic: ext (l m)
state_before: ι : Type u₁
k : Type u₂
V : Type u₃
P : Type u₄
inst✝⁶ : AddCommGroup V
inst✝⁵ : AffineSpace V P
inst✝⁴ : Ring k
inst✝³ : Module k V
b : AffineBasis ι k P
ι' : Type ?u.67411
inst✝² : Fintype ι'
inst✝¹ : Fintype ι
b₂ : AffineBasis ι k P
inst✝ : DecidableEq ι
⊢ toMatrix b ↑b₂ ⬝ toMatrix b₂ ↑b = 1

tactic: change (b₂.toMatrix b).vecMul (b.coords (b₂ l)) m = _
state_before: case a.h
ι : Type u₁
k : Type u₂
V : Type u₃
P : Type u₄
inst✝⁶ : AddCommGroup V
inst✝⁵ : AffineSpace V P
inst✝⁴ : Ring k
inst✝³ : Module k V
b : AffineBasis ι k P
ι' : Type ?u.67411
inst✝² : Fintype ι'
inst✝¹ : Fintype ι
b₂ : AffineBasis ι k P
inst✝ : DecidableEq ι
l m : ι
⊢ (toMatrix b ↑b₂ ⬝ toMatrix b₂ ↑b) l m = OfNat.ofNat 1 l m

tactic: rw [toMatrix_vecMul_coords, coords_apply, ← toMatrix_apply, toMatrix_self]
state_before: case a.h
ι : Type u₁
k : Type u₂
V : Type u₃
P : Type u₄
inst✝⁶ : AddCommGroup V
inst✝⁵ : AffineSpace V P
inst✝⁴ : Ring k
inst✝³ : Module k V
b : AffineBasis ι k P
ι' : Type ?u.67411
inst✝² : Fintype ι'
inst✝¹ : Fintype ι
b₂ : AffineBasis ι k P
inst✝ : DecidableEq ι
l m : ι
⊢ vecMul (↑(coords b) (↑b₂ l)) (toMatrix b₂ ↑b) m = OfNat.ofNat 1 l m
Theorem: Subgroup.coe_iSup_of_directed
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: simp [mem_iSup_of_directed hS]
state_before: G : Type u_2
G' : Type ?u.226690
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.226699
inst✝¹ : AddGroup A
H K : Subgroup G
k : Set G
ι : Sort u_1
inst✝ : Nonempty ι
S : ι → Subgroup G
hS : Directed (fun x x_1 => x ≤ x_1) S
x : G
⊢ x ∈ ↑(⨆ (i : ι), S i) ↔ x ∈ ⋃ (i : ι), ↑(S i)
Theorem: FiniteDimensional.finiteDimensional_of_finrank_eq_succ
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: rw [hn]
state_before: K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
V₂ : Type v'
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
n : ℕ
hn : finrank K V = Nat.succ n
⊢ 0 < finrank K V

tactic: exact n.succ_pos
state_before: K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
V₂ : Type v'
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
n : ℕ
hn : finrank K V = Nat.succ n
⊢ 0 < Nat.succ n