tasksource/leandojo huggingface dataset:
Theorem: EuclideanDomain.mul_div_mul_cancel
File: Mathlib/Algebra/EuclideanDomain/Basic.lean

tactic: by_cases hc : c = 0
state_before: R : Type u
inst✝ : EuclideanDomain R
a b c : R
ha : a ≠ 0
hcb : c ∣ b
⊢ a * b / (a * c) = b / c

tactic: refine' eq_div_of_mul_eq_right hc (mul_left_cancel₀ ha _)
state_before: case neg
R : Type u
inst✝ : EuclideanDomain R
a b c : R
ha : a ≠ 0
hcb : c ∣ b
hc : ¬c = 0
⊢ a * b / (a * c) = b / c

tactic: rw [← mul_assoc, ← mul_div_assoc _ (mul_dvd_mul_left a hcb),
  mul_div_cancel_left _ (mul_ne_zero ha hc)]
state_before: case neg
R : Type u
inst✝ : EuclideanDomain R
a b c : R
ha : a ≠ 0
hcb : c ∣ b
hc : ¬c = 0
⊢ a * (c * (a * b / (a * c))) = a * b

tactic: simp [hc]
state_before: case pos
R : Type u
inst✝ : EuclideanDomain R
a b c : R
ha : a ≠ 0
hcb : c ∣ b
hc : c = 0
⊢ a * b / (a * c) = b / c
Theorem: Monotone.map_csSup_of_continuousAt
File: Mathlib/Topology/Order/Basic.lean

tactic: refine' ((isLUB_csSup (ne.image f) (Mf.map_bddAbove H)).unique _).symm
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁶ : ConditionallyCompleteLinearOrder α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : OrderTopology α
inst✝³ : ConditionallyCompleteLinearOrder β
inst✝² : TopologicalSpace β
inst✝¹ : OrderClosedTopology β
inst✝ : Nonempty γ
f : α → β
s : Set α
Cf : ContinuousAt f (sSup s)
Mf : Monotone f
ne : Set.Nonempty s
H : BddAbove s
⊢ f (sSup s) = sSup (f '' s)

tactic: refine' (isLUB_csSup ne H).isLUB_of_tendsto (fun x _ y _ xy => Mf xy) ne _
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁶ : ConditionallyCompleteLinearOrder α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : OrderTopology α
inst✝³ : ConditionallyCompleteLinearOrder β
inst✝² : TopologicalSpace β
inst✝¹ : OrderClosedTopology β
inst✝ : Nonempty γ
f : α → β
s : Set α
Cf : ContinuousAt f (sSup s)
Mf : Monotone f
ne : Set.Nonempty s
H : BddAbove s
⊢ IsLUB (f '' s) (f (sSup s))

tactic: exact Cf.mono_left inf_le_left
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁶ : ConditionallyCompleteLinearOrder α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : OrderTopology α
inst✝³ : ConditionallyCompleteLinearOrder β
inst✝² : TopologicalSpace β
inst✝¹ : OrderClosedTopology β
inst✝ : Nonempty γ
f : α → β
s : Set α
Cf : ContinuousAt f (sSup s)
Mf : Monotone f
ne : Set.Nonempty s
H : BddAbove s
⊢ Tendsto f (𝓝[s] sSup s) (𝓝 (f (sSup s)))
Theorem: Finsupp.equivMapDomain_trans'
File: Mathlib/Data/Finsupp/Basic.lean

tactic: ext x
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type ?u.142684
M : Type u_4
M' : Type ?u.142690
N : Type ?u.142693
P : Type ?u.142696
G : Type ?u.142699
H : Type ?u.142702
R : Type ?u.142705
S : Type ?u.142708
inst✝ : Zero M
f : α ≃ β
g : β ≃ γ
⊢ equivMapDomain (f.trans g) = equivMapDomain g ∘ equivMapDomain f

tactic: rfl
state_before: case h.h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type ?u.142684
M : Type u_4
M' : Type ?u.142690
N : Type ?u.142693
P : Type ?u.142696
G : Type ?u.142699
H : Type ?u.142702
R : Type ?u.142705
S : Type ?u.142708
inst✝ : Zero M
f : α ≃ β
g : β ≃ γ
x : α →₀ M
a✝ : γ
⊢ ↑(equivMapDomain (f.trans g) x) a✝ = ↑((equivMapDomain g ∘ equivMapDomain f) x) a✝
Theorem: PNat.factorMultiset_le_iff
File: Mathlib/Data/PNat/Factors.lean

tactic: constructor
state_before: m n : ℕ+
⊢ factorMultiset m ≤ factorMultiset n ↔ m ∣ n

tactic: intro h
state_before: case mp
m n : ℕ+
⊢ factorMultiset m ≤ factorMultiset n → m ∣ n

tactic: rw [← prod_factorMultiset m, ← prod_factorMultiset m]
state_before: case mp
m n : ℕ+
h : factorMultiset m ≤ factorMultiset n
⊢ m ∣ n

tactic: apply Dvd.intro (n.factorMultiset - m.factorMultiset).prod
state_before: case mp
m n : ℕ+
h : factorMultiset m ≤ factorMultiset n
⊢ PrimeMultiset.prod (factorMultiset (PrimeMultiset.prod (factorMultiset m))) ∣ n

tactic: rw [← PrimeMultiset.prod_add, PrimeMultiset.factorMultiset_prod, add_tsub_cancel_of_le h,
  prod_factorMultiset]
state_before: case mp
m n : ℕ+
h : factorMultiset m ≤ factorMultiset n
⊢ PrimeMultiset.prod (factorMultiset (PrimeMultiset.prod (factorMultiset m))) *
      PrimeMultiset.prod (factorMultiset n - factorMultiset m) =
    n

tactic: intro h
state_before: case mpr
m n : ℕ+
⊢ m ∣ n → factorMultiset m ≤ factorMultiset n

tactic: rw [← mul_div_exact h, factorMultiset_mul]
state_before: case mpr
m n : ℕ+
h : m ∣ n
⊢ factorMultiset m ≤ factorMultiset n

tactic: exact le_self_add
state_before: case mpr
m n : ℕ+
h : m ∣ n
⊢ factorMultiset m ≤ factorMultiset m + factorMultiset (divExact n m)
Theorem: MvPolynomial.X_dvd_monomial
File: Mathlib/Data/MvPolynomial/Division.lean

tactic: refine' monomial_dvd_monomial.trans _
state_before: σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
i : σ
j : σ →₀ ℕ
r : R
⊢ X i ∣ ↑(monomial j) r ↔ r = 0 ∨ ↑j i ≠ 0

tactic: simp_rw [one_dvd, and_true_iff, Finsupp.single_le_iff, Nat.one_le_iff_ne_zero]
state_before: σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
i : σ
j : σ →₀ ℕ
r : R
⊢ (r = 0 ∨ Finsupp.single i 1 ≤ j) ∧ 1 ∣ r ↔ r = 0 ∨ ↑j i ≠ 0
Theorem: Polynomial.eval_eq_sum
File: Mathlib/Data/Polynomial/Eval.lean

tactic: rw [eval, eval₂_eq_sum]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
x : R
⊢ eval x p = sum p fun e a => a * x ^ e

tactic: rfl
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
x : R
⊢ (sum p fun e a => ↑(RingHom.id R) a * x ^ e) = sum p fun e a => a * x ^ e
Theorem: MeasureTheory.integrable_of_summable_norm_restrict
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

tactic: simpa only [hs, integrableOn_univ] using integrableOn_iUnion_of_summable_norm_restrict hf
state_before: α : Type u_1
β : Type u_3
E : Type u_2
F : Type ?u.312326
inst✝⁶ : MeasurableSpace α
μ : Measure α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : Countable β
inst✝³ : TopologicalSpace α
inst✝² : BorelSpace α
inst✝¹ : MetrizableSpace α
inst✝ : IsLocallyFiniteMeasure μ
f : C(α, E)
s : β → Compacts α
hf : Summable fun i => ‖ContinuousMap.restrict (↑(s i)) f‖ * ENNReal.toReal (↑↑μ ↑(s i))
hs : (⋃ (i : β), ↑(s i)) = univ
⊢ Integrable ↑f
Theorem: one_add_mul
File: Mathlib/Algebra/Ring/Defs.lean

tactic: rw [add_mul, one_mul]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝² : Add α
inst✝¹ : MulOneClass α
inst✝ : RightDistribClass α
a b : α
⊢ (1 + a) * b = b + a * b
Theorem: Multiset.toFinset_prod_dvd_prod
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: rw [Finset.prod_eq_multiset_prod]
state_before: ι : Type ?u.942035
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : DecidableEq α
inst✝ : CommMonoid α
S : Multiset α
⊢ Finset.prod (toFinset S) id ∣ prod S

tactic: refine' Multiset.prod_dvd_prod_of_le _
state_before: ι : Type ?u.942035
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : DecidableEq α
inst✝ : CommMonoid α
S : Multiset α
⊢ prod (map (fun x => id x) (toFinset S).val) ∣ prod S

tactic: simp [Multiset.dedup_le S]
state_before: ι : Type ?u.942035
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : DecidableEq α
inst✝ : CommMonoid α
S : Multiset α
⊢ map (fun x => id x) (toFinset S).val ≤ S
Theorem: Ideal.comap_bot_le_of_injective
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: refine' le_trans (fun x hx => _) bot_le
state_before: R : Type u
S : Type v
F : Type u_1
inst✝¹ : Semiring R
inst✝ : Semiring S
rc : RingHomClass F R S
f : F
I J : Ideal R
K L : Ideal S
G : Type ?u.1181788
rcg : RingHomClass G S R
ι : Sort ?u.1181822
hf : Function.Injective ↑f
⊢ comap f ⊥ ≤ I

tactic: rw [mem_comap, Submodule.mem_bot, ← map_zero f] at hx
state_before: R : Type u
S : Type v
F : Type u_1
inst✝¹ : Semiring R
inst✝ : Semiring S
rc : RingHomClass F R S
f : F
I J : Ideal R
K L : Ideal S
G : Type ?u.1181788
rcg : RingHomClass G S R
ι : Sort ?u.1181822
hf : Function.Injective ↑f
x : R
hx : x ∈ comap f ⊥
⊢ x ∈ ⊥

tactic: exact Eq.symm (hf hx) ▸ Submodule.zero_mem ⊥
state_before: R : Type u
S : Type v
F : Type u_1
inst✝¹ : Semiring R
inst✝ : Semiring S
rc : RingHomClass F R S
f : F
I J : Ideal R
K L : Ideal S
G : Type ?u.1181788
rcg : RingHomClass G S R
ι : Sort ?u.1181822
hf : Function.Injective ↑f
x : R
hx : ↑f x = ↑f 0
⊢ x ∈ ⊥
Theorem: WittVector.addIsPoly₂
File: Mathlib/RingTheory/WittVector/IsPoly.lean

tactic: intros
state_before: p : ℕ
R S : Type u
σ : Type ?u.696083
idx : Type ?u.696086
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Fact (Nat.Prime p)
⊢ ∀ ⦃R : Type u_1⦄ [inst : CommRing R] (x y : 𝕎 R), (x + y).coeff = fun n => peval (wittAdd p n) ![x.coeff, y.coeff]

tactic: ext
state_before: p : ℕ
R S : Type u
σ : Type ?u.696083
idx : Type ?u.696086
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Fact (Nat.Prime p)
R✝ : Type u_1
inst✝ : CommRing R✝
x✝ y✝ : 𝕎 R✝
⊢ (x✝ + y✝).coeff = fun n => peval (wittAdd p n) ![x✝.coeff, y✝.coeff]

tactic: exact add_coeff _ _ _
state_before: case h
p : ℕ
R S : Type u
σ : Type ?u.696083
idx : Type ?u.696086
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Fact (Nat.Prime p)
R✝ : Type u_1
inst✝ : CommRing R✝
x✝¹ y✝ : 𝕎 R✝
x✝ : ℕ
⊢ coeff (x✝¹ + y✝) x✝ = peval (wittAdd p x✝) ![x✝¹.coeff, y✝.coeff]
Theorem: MeasureTheory.VectorMeasure.restrict_smul
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: by_cases hi : MeasurableSet i
state_before: α : Type u_1
β : Type ?u.514959
m : MeasurableSpace α
inst✝⁵ : MeasurableSpace β
M : Type u_2
inst✝⁴ : AddCommMonoid M
inst✝³ : TopologicalSpace M
R : Type u_3
inst✝² : Semiring R
inst✝¹ : DistribMulAction R M
inst✝ : ContinuousConstSMul R M
v : VectorMeasure α M
i : Set α
c : R
⊢ restrict (c • v) i = c • restrict v i

tactic: ext j
state_before: case pos
α : Type u_1
β : Type ?u.514959
m : MeasurableSpace α
inst✝⁵ : MeasurableSpace β
M : Type u_2
inst✝⁴ : AddCommMonoid M
inst✝³ : TopologicalSpace M
R : Type u_3
inst✝² : Semiring R
inst✝¹ : DistribMulAction R M
inst✝ : ContinuousConstSMul R M
v : VectorMeasure α M
i : Set α
c : R
hi : MeasurableSet i
⊢ restrict (c • v) i = c • restrict v i

tactic: intro hj
state_before: case pos.h
α : Type u_1
β : Type ?u.514959
m : MeasurableSpace α
inst✝⁵ : MeasurableSpace β
M : Type u_2
inst✝⁴ : AddCommMonoid M
inst✝³ : TopologicalSpace M
R : Type u_3
inst✝² : Semiring R
inst✝¹ : DistribMulAction R M
inst✝ : ContinuousConstSMul R M
v : VectorMeasure α M
i : Set α
c : R
hi : MeasurableSet i
j : Set α
⊢ MeasurableSet j → ↑(restrict (c • v) i) j = ↑(c • restrict v i) j

tactic: simp [restrict_apply _ hi hj]
state_before: case pos.h
α : Type u_1
β : Type ?u.514959
m : MeasurableSpace α
inst✝⁵ : MeasurableSpace β
M : Type u_2
inst✝⁴ : AddCommMonoid M
inst✝³ : TopologicalSpace M
R : Type u_3
inst✝² : Semiring R
inst✝¹ : DistribMulAction R M
inst✝ : ContinuousConstSMul R M
v : VectorMeasure α M
i : Set α
c : R
hi : MeasurableSet i
j : Set α
hj : MeasurableSet j
⊢ ↑(restrict (c • v) i) j = ↑(c • restrict v i) j

tactic: simp only [restrict_not_measurable _ hi]
state_before: case neg
α : Type u_1
β : Type ?u.514959
m : MeasurableSpace α
inst✝⁵ : MeasurableSpace β
M : Type u_2
inst✝⁴ : AddCommMonoid M
inst✝³ : TopologicalSpace M
R : Type u_3
inst✝² : Semiring R
inst✝¹ : DistribMulAction R M
inst✝ : ContinuousConstSMul R M
v : VectorMeasure α M
i : Set α
c : R
hi : ¬MeasurableSet i
⊢ restrict (c • v) i = c • restrict v i

tactic: ext j
state_before: case neg
α : Type u_1
β : Type ?u.514959
m : MeasurableSpace α
inst✝⁵ : MeasurableSpace β
M : Type u_2
inst✝⁴ : AddCommMonoid M
inst✝³ : TopologicalSpace M
R : Type u_3
inst✝² : Semiring R
inst✝¹ : DistribMulAction R M
inst✝ : ContinuousConstSMul R M
v : VectorMeasure α M
i : Set α
c : R
hi : ¬MeasurableSet i
⊢ 0 = c • 0

tactic: simp
state_before: case neg.h
α : Type u_1
β : Type ?u.514959
m : MeasurableSpace α
inst✝⁵ : MeasurableSpace β
M : Type u_2
inst✝⁴ : AddCommMonoid M
inst✝³ : TopologicalSpace M
R : Type u_3
inst✝² : Semiring R
inst✝¹ : DistribMulAction R M
inst✝ : ContinuousConstSMul R M
v : VectorMeasure α M
i : Set α
c : R
hi : ¬MeasurableSet i
j : Set α
⊢ MeasurableSet j → ↑0 j = ↑(c • 0) j
Theorem: Std.PairingHeapImp.Heap.WF.merge_node
File: Std/Data/PairingHeap.lean

tactic: unfold merge
state_before: α✝ : Type u_1
le : α✝ → α✝ → Bool
a₁ : α✝
c₁ : Heap α✝
a₂ : α✝
c₂ s₁ s₂ : Heap α✝
h₁ : NodeWF le a₁ c₁
h₂ : NodeWF le a₂ c₂
⊢ WF le (merge le (Heap.node a₁ c₁ s₁) (Heap.node a₂ c₂ s₂))

tactic: dsimp
state_before: α✝ : Type u_1
le : α✝ → α✝ → Bool
a₁ : α✝
c₁ : Heap α✝
a₂ : α✝
c₂ s₁ s₂ : Heap α✝
h₁ : NodeWF le a₁ c₁
h₂ : NodeWF le a₂ c₂
⊢ WF le
    (match Heap.node a₁ c₁ s₁, Heap.node a₂ c₂ s₂ with
    | Heap.nil, Heap.nil => Heap.nil
    | Heap.nil, Heap.node a₂ c₂ sibling => Heap.node a₂ c₂ Heap.nil
    | Heap.node a₁ c₁ sibling, Heap.nil => Heap.node a₁ c₁ Heap.nil
    | Heap.node a₁ c₁ sibling, Heap.node a₂ c₂ sibling_1 =>
      if le a₁ a₂ = true then Heap.node a₁ (Heap.node a₂ c₂ c₁) Heap.nil
      else Heap.node a₂ (Heap.node a₁ c₁ c₂) Heap.nil)

tactic: split <;> rename_i h
state_before: α✝ : Type u_1
le : α✝ → α✝ → Bool
a₁ : α✝
c₁ : Heap α✝
a₂ : α✝
c₂ s₁ s₂ : Heap α✝
h₁ : NodeWF le a₁ c₁
h₂ : NodeWF le a₂ c₂
⊢ WF le
    (if le a₁ a₂ = true then Heap.node a₁ (Heap.node a₂ c₂ c₁) Heap.nil else Heap.node a₂ (Heap.node a₁ c₁ c₂) Heap.nil)

tactic: exact node ⟨fun [_] => h, h₂, h₁⟩
state_before: case inl
α✝ : Type u_1
le : α✝ → α✝ → Bool
a₁ : α✝
c₁ : Heap α✝
a₂ : α✝
c₂ s₁ s₂ : Heap α✝
h₁ : NodeWF le a₁ c₁
h₂ : NodeWF le a₂ c₂
h : le a₁ a₂ = true
⊢ WF le (Heap.node a₁ (Heap.node a₂ c₂ c₁) Heap.nil)

tactic: exact node ⟨fun [_] => TotalBLE.total.resolve_left h, h₁, h₂⟩
state_before: case inr
α✝ : Type u_1
le : α✝ → α✝ → Bool
a₁ : α✝
c₁ : Heap α✝
a₂ : α✝
c₂ s₁ s₂ : Heap α✝
h₁ : NodeWF le a₁ c₁
h₂ : NodeWF le a₂ c₂
h : ¬le a₁ a₂ = true
⊢ WF le (Heap.node a₂ (Heap.node a₁ c₁ c₂) Heap.nil)
Theorem: Matrix.dotProduct_self_eq_zero
File: Mathlib/LinearAlgebra/Matrix/DotProduct.lean

tactic: simp [Function.funext_iff]
state_before: R : Type v
n : Type w
inst✝¹ : Fintype n
inst✝ : LinearOrderedRing R
v : n → R
⊢ (∀ (i : n), i ∈ Finset.univ → v i * v i = 0) ↔ v = 0
Theorem: continuous_of_scottContinuous
File: Mathlib/Topology/OmegaCompletePartialOrder.lean

tactic: rw [continuous_def]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : OmegaCompletePartialOrder β
f : Scott α → Scott β
hf : Continuous' f
⊢ _root_.Continuous f

tactic: intro s hs
state_before: α : Type u_1
β : Type u_2
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : OmegaCompletePartialOrder β
f : Scott α → Scott β
hf : Continuous' f
⊢ ∀ (s : Set (Scott β)), IsOpen s → IsOpen (f ⁻¹' s)

tactic: change Continuous' (s ∘ f)
state_before: α : Type u_1
β : Type u_2
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : OmegaCompletePartialOrder β
f : Scott α → Scott β
hf : Continuous' f
s : Set (Scott β)
hs : IsOpen s
⊢ IsOpen (f ⁻¹' s)

tactic: cases' hs with hs hs'
state_before: α : Type u_1
β : Type u_2
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : OmegaCompletePartialOrder β
f : Scott α → Scott β
hf : Continuous' f
s : Set (Scott β)
hs : IsOpen s
⊢ Continuous' (s ∘ f)

tactic: cases' hf with hf hf'
state_before: case intro
α : Type u_1
β : Type u_2
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : OmegaCompletePartialOrder β
f : Scott α → Scott β
hf : Continuous' f
s : Set (Scott β)
hs : Monotone fun x => x ∈ s
hs' : OmegaCompletePartialOrder.Continuous { toFun := fun x => x ∈ s, monotone' := hs }
⊢ Continuous' (s ∘ f)

tactic: apply Continuous.of_bundled
state_before: case intro.intro
α : Type u_1
β : Type u_2
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : OmegaCompletePartialOrder β
f : Scott α → Scott β
s : Set (Scott β)
hs : Monotone fun x => x ∈ s
hs' : OmegaCompletePartialOrder.Continuous { toFun := fun x => x ∈ s, monotone' := hs }
hf : Monotone f
hf' : OmegaCompletePartialOrder.Continuous { toFun := f, monotone' := hf }
⊢ Continuous' (s ∘ f)

tactic: apply continuous_comp _ _ hf' hs'
state_before: case intro.intro.hf'
α : Type u_1
β : Type u_2
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : OmegaCompletePartialOrder β
f : Scott α → Scott β
s : Set (Scott β)
hs : Monotone fun x => x ∈ s
hs' : OmegaCompletePartialOrder.Continuous { toFun := fun x => x ∈ s, monotone' := hs }
hf : Monotone f
hf' : OmegaCompletePartialOrder.Continuous { toFun := f, monotone' := hf }
⊢ OmegaCompletePartialOrder.Continuous { toFun := s ∘ f, monotone' := ?intro.intro.hf }

case intro.intro.hf
α : Type u_1
β : Type u_2
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : OmegaCompletePartialOrder β
f : Scott α → Scott β
s : Set (Scott β)
hs : Monotone fun x => x ∈ s
hs' : OmegaCompletePartialOrder.Continuous { toFun := fun x => x ∈ s, monotone' := hs }
hf : Monotone f
hf' : OmegaCompletePartialOrder.Continuous { toFun := f, monotone' := hf }
⊢ Monotone (s ∘ f)
Theorem: Finset.Ico_union_Ico_eq_Ico
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: rw [← coe_inj, coe_union, coe_Ico, coe_Ico, coe_Ico, Set.Ico_union_Ico_eq_Ico hab hbc]
state_before: ι : Type ?u.123560
α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ a b c : α
hab : a ≤ b
hbc : b ≤ c
⊢ Ico a b ∪ Ico b c = Ico a c
Theorem: sq_lt_sq
File: Mathlib/Algebra/GroupPower/Order.lean

tactic: simpa only [sq_abs] using
  (@strictMonoOn_pow R _ _ two_pos).lt_iff_lt (abs_nonneg x) (abs_nonneg y)
state_before: β : Type ?u.257384
A : Type ?u.257387
G : Type ?u.257390
M : Type ?u.257393
R : Type u_1
inst✝ : LinearOrderedRing R
x y : R
⊢ x ^ 2 < y ^ 2 ↔ abs x < abs y
Theorem: List.IsRotated.symm
File: Mathlib/Data/List/Rotate.lean

tactic: obtain ⟨n, rfl⟩ := h
state_before: α : Type u
l l' : List α
h : l ~r l'
⊢ l' ~r l

tactic: cases' l with hd tl
state_before: case intro
α : Type u
l : List α
n : ℕ
⊢ rotate l n ~r l

tactic: exists 0
state_before: case intro.nil
α : Type u
n : ℕ
⊢ rotate [] n ~r []

tactic: use (hd :: tl).length * n - n
state_before: case intro.cons
α : Type u
n : ℕ
hd : α
tl : List α
⊢ rotate (hd :: tl) n ~r (hd :: tl)

tactic: rw [rotate_rotate, add_tsub_cancel_of_le, rotate_length_mul]
state_before: case intro.cons
α : Type u
n : ℕ
hd : α
tl : List α
⊢ rotate (rotate (hd :: tl) n) (length (hd :: tl) * n - n) = hd :: tl

tactic: exact Nat.le_mul_of_pos_left (by simp)
state_before: case intro.cons
α : Type u
n : ℕ
hd : α
tl : List α
⊢ n ≤ length (hd :: tl) * n

tactic: simp
state_before: α : Type u
n : ℕ
hd : α
tl : List α
⊢ 0 < length (hd :: tl)
Theorem: EuclideanDomain.dvd_gcd
File: Mathlib/Algebra/EuclideanDomain/Basic.lean

tactic: simpa only [gcd_zero_left] using H
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
a b c x✝¹ : R
x✝ : c ∣ 0
H : c ∣ x✝¹
⊢ c ∣ gcd 0 x✝¹

tactic: rw [gcd_val]
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
a✝ b✝ c a b : R
x✝ : a ≠ 0
IH : c ∣ b % a → c ∣ a → c ∣ gcd (b % a) a
ca : c ∣ a
cb : c ∣ b
⊢ c ∣ gcd a b

tactic: exact IH ((dvd_mod_iff ca).2 cb) ca
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
a✝ b✝ c a b : R
x✝ : a ≠ 0
IH : c ∣ b % a → c ∣ a → c ∣ gcd (b % a) a
ca : c ∣ a
cb : c ∣ b
⊢ c ∣ gcd (b % a) a
Theorem: Std.OrientedCmp.cmp_eq_gt
File: Std/Classes/Order.lean

tactic: rw [← Ordering.swap_inj, symm]
state_before: α✝ : Sort u_1
cmp : α✝ → α✝ → Ordering
x y : α✝
inst✝ : OrientedCmp cmp
⊢ cmp x y = Ordering.gt ↔ cmp y x = Ordering.lt

tactic: exact .rfl
state_before: α✝ : Sort u_1
cmp : α✝ → α✝ → Ordering
x y : α✝
inst✝ : OrientedCmp cmp
⊢ cmp y x = Ordering.swap Ordering.gt ↔ cmp y x = Ordering.lt
Theorem: specializes_pi
File: Mathlib/Topology/Inseparable.lean

tactic: simp only [Specializes, nhds_pi, pi_le_pi]
state_before: X : Type ?u.16376
Y : Type ?u.16379
Z : Type ?u.16382
α : Type ?u.16385
ι : Type u_1
π : ι → Type u_2
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x y z : X
s : Set X
f✝ : X → Y
f g : (i : ι) → π i
⊢ f ⤳ g ↔ ∀ (i : ι), f i ⤳ g i
Theorem: FiniteDimensional.nonempty_linearEquiv_of_finrank_eq
File: Mathlib/LinearAlgebra/FreeModule/Finite/Rank.lean

tactic: simp only [← finrank_eq_rank, cond, lift_natCast]
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
cond : finrank R M = finrank R N
⊢ Cardinal.lift (Module.rank R M) = Cardinal.lift (Module.rank R N)
Theorem: Convex.affinity
File: Mathlib/Analysis/Convex/Basic.lean

tactic: simpa only [← image_smul, ← image_vadd, image_image] using (hs.smul c).vadd z
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.180457
β : Type ?u.180460
inst✝⁴ : OrderedCommSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
hs : Convex 𝕜 s
z : E
c : 𝕜
⊢ Convex 𝕜 ((fun x => z + c • x) '' s)
Theorem: Finset.card_image_le
File: Mathlib/Data/Finset/Card.lean

tactic: simpa only [card_map] using (s.1.map f).toFinset_card_le
state_before: α : Type u_2
β : Type u_1
s t : Finset α
f : α → β
n : ℕ
inst✝ : DecidableEq β
⊢ card (image f s) ≤ card s
Theorem: Int.dvd_antisymm
File: Std/Data/Int/DivMod.lean

tactic: rw [← natAbs_of_nonneg H1, ← natAbs_of_nonneg H2]
state_before: a b : Int
H1 : 0 ≤ a
H2 : 0 ≤ b
⊢ a ∣ b → b ∣ a → a = b

tactic: rw [ofNat_dvd, ofNat_dvd, ofNat_inj]
state_before: a b : Int
H1 : 0 ≤ a
H2 : 0 ≤ b
⊢ ↑(natAbs a) ∣ ↑(natAbs b) → ↑(natAbs b) ∣ ↑(natAbs a) → ↑(natAbs a) = ↑(natAbs b)

tactic: apply Nat.dvd_antisymm
state_before: a b : Int
H1 : 0 ≤ a
H2 : 0 ≤ b
⊢ natAbs a ∣ natAbs b → natAbs b ∣ natAbs a → natAbs a = natAbs b
Theorem: map_div_rev
File: Mathlib/Algebra/Order/Hom/Basic.lean

tactic: rw [← inv_div, map_inv_eq_map]
state_before: ι : Type ?u.38496
F : Type u_3
α : Type u_2
β : Type u_1
γ : Type ?u.38508
δ : Type ?u.38511
inst✝² : Group α
inst✝¹ : OrderedAddCommMonoid β
inst✝ : GroupSeminormClass F α β
f : F
x y : α
⊢ ↑f (x / y) = ↑f (y / x)
Theorem: AlgebraicTopology.DoldKan.Q_is_eventually_constant
File: Mathlib/AlgebraicTopology/DoldKan/PInfty.lean

tactic: simp only [Q, HomologicalComplex.sub_f_apply, P_is_eventually_constant hqn]
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
q n : ℕ
hqn : n ≤ q
⊢ HomologicalComplex.Hom.f (Q (q + 1)) n = HomologicalComplex.Hom.f (Q q) n
Theorem: Polynomial.expand_char
File: Mathlib/Data/Polynomial/Expand.lean

tactic: refine' f.induction_on' (fun a b ha hb => _) fun n a => _
state_before: R : Type u
inst✝² : CommSemiring R
S : Type v
inst✝¹ : CommSemiring S
p q : ℕ
inst✝ : CharP R p
hp : Fact (Nat.Prime p)
f : R[X]
⊢ map (frobenius R p) (↑(expand R p) f) = f ^ p

tactic: rw [AlgHom.map_add, Polynomial.map_add, ha, hb, add_pow_char]
state_before: case refine'_1
R : Type u
inst✝² : CommSemiring R
S : Type v
inst✝¹ : CommSemiring S
p q : ℕ
inst✝ : CharP R p
hp : Fact (Nat.Prime p)
f a b : R[X]
ha : map (frobenius R p) (↑(expand R p) a) = a ^ p
hb : map (frobenius R p) (↑(expand R p) b) = b ^ p
⊢ map (frobenius R p) (↑(expand R p) (a + b)) = (a + b) ^ p

tactic: rw [expand_monomial, map_monomial, ← C_mul_X_pow_eq_monomial, ← C_mul_X_pow_eq_monomial,
  mul_pow, ← C.map_pow, frobenius_def]
state_before: case refine'_2
R : Type u
inst✝² : CommSemiring R
S : Type v
inst✝¹ : CommSemiring S
p q : ℕ
inst✝ : CharP R p
hp : Fact (Nat.Prime p)
f : R[X]
n : ℕ
a : R
⊢ map (frobenius R p) (↑(expand R p) (↑(monomial n) a)) = ↑(monomial n) a ^ p

tactic: ring
state_before: case refine'_2
R : Type u
inst✝² : CommSemiring R
S : Type v
inst✝¹ : CommSemiring S
p q : ℕ
inst✝ : CharP R p
hp : Fact (Nat.Prime p)
f : R[X]
n : ℕ
a : R
⊢ ↑C (a ^ p) * X ^ (n * p) = ↑C (a ^ p) * (X ^ n) ^ p
Theorem: Subsemigroup.top_prod
File: Mathlib/GroupTheory/Subsemigroup/Operations.lean

tactic: simp [mem_prod, MulHom.coe_snd]
state_before: M : Type u_2
N : Type u_1
P : Type ?u.51321
σ : Type ?u.51324
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
S : Subsemigroup M
s : Subsemigroup N
x : M × N
⊢ x ∈ prod ⊤ s ↔ x ∈ comap (MulHom.snd M N) s
Theorem: List.isRotated_nil_iff
File: Mathlib/Data/List/Rotate.lean

tactic: simpa using hn
state_before: α : Type u
l l' : List α
x✝ : l ~r []
n : ℕ
hn : rotate l n = []
⊢ l = []

tactic: rfl
state_before: α : Type u
l l' : List α
h : l = []
⊢ l ~r l
Theorem: Bool.decide_and
File: Mathlib/Data/Bool/Basic.lean

tactic: by_cases p <;> by_cases q <;> simp [*]
state_before: p q : Prop
inst✝¹ : Decidable p
inst✝ : Decidable q
⊢ decide (p ∧ q) = (decide p && decide q)