tasksource/leandojo huggingface dataset:
Theorem: Computable.list_ofFn
File: Mathlib/Computability/Partrec.lean

tactic: simp [List.ofFn_succ]
state_before: α : Type u_1
β : Type ?u.207104
γ : Type ?u.207107
σ : Type u_2
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
n : ℕ
f : Fin (n + 1) → α → σ
hf : ∀ (i : Fin (n + 1)), Computable (f i)
⊢ Computable fun a => List.ofFn fun i => f i a

tactic: exact list_cons.comp (hf 0) (list_ofFn fun i => hf i.succ)
state_before: α : Type u_1
β : Type ?u.207104
γ : Type ?u.207107
σ : Type u_2
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
n : ℕ
f : Fin (n + 1) → α → σ
hf : ∀ (i : Fin (n + 1)), Computable (f i)
⊢ Computable fun a => f 0 a :: List.ofFn fun i => f (Fin.succ i) a
Theorem: CompositionSeries.append_natAdd_aux
File: Mathlib/Order/JordanHolder.lean

tactic: cases i
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
α : Type u_1
m n : ℕ
a : Fin (Nat.succ m) → α
b : Fin (Nat.succ n) → α
i : Fin n
⊢ Matrix.vecAppend (_ : Nat.succ (m + n) = m + Nat.succ n) (a ∘ ↑Fin.castSucc) b (↑Fin.castSucc (↑(Fin.natAdd m) i)) =
    b (↑Fin.castSucc i)

tactic: simp only [Matrix.vecAppend_eq_ite, Nat.not_lt_zero, Fin.natAdd_mk, add_lt_iff_neg_left,
  add_tsub_cancel_left, dif_neg, Fin.castSucc_mk, not_false_iff, Fin.val_mk]
state_before: case mk
X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
α : Type u_1
m n : ℕ
a : Fin (Nat.succ m) → α
b : Fin (Nat.succ n) → α
val✝ : ℕ
isLt✝ : val✝ < n
⊢ Matrix.vecAppend (_ : Nat.succ (m + n) = m + Nat.succ n) (a ∘ ↑Fin.castSucc) b
      (↑Fin.castSucc (↑(Fin.natAdd m) { val := val✝, isLt := isLt✝ })) =
    b (↑Fin.castSucc { val := val✝, isLt := isLt✝ })
Theorem: QuaternionAlgebra.star_coe
File: Mathlib/Algebra/Quaternion.lean

tactic: ext <;> simp
state_before: S : Type ?u.314480
T : Type ?u.314483
R : Type u_1
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
⊢ star ↑x = ↑x
Theorem: Nat.map_floor
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [← map_natCast f, hf.le_iff_le]
state_before: F : Type u_3
α : Type u_1
β : Type u_2
inst✝⁴ : LinearOrderedSemiring α
inst✝³ : LinearOrderedSemiring β
inst✝² : FloorSemiring α
inst✝¹ : FloorSemiring β
inst✝ : RingHomClass F α β
a✝ : α
b : β
f : F
hf : StrictMono ↑f
a : α
n : ℕ
⊢ ↑n ≤ ↑f a ↔ ↑n ≤ a
Theorem: padicValNat.pow_add_pow
File: Mathlib/NumberTheory/Multiplicity.lean

tactic: cases' y with y
state_before: R : Type ?u.883070
n✝ x y p : ℕ
hp : Fact (Nat.Prime p)
hp1 : Odd p
hxy : p ∣ x + y
hx : ¬p ∣ x
n : ℕ
hn : Odd n
⊢ padicValNat p (x ^ n + y ^ n) = padicValNat p (x + y) + padicValNat p n

tactic: rw [← PartENat.natCast_inj, Nat.cast_add]
state_before: case succ
R : Type ?u.883070
n✝ x p : ℕ
hp : Fact (Nat.Prime p)
hp1 : Odd p
hx : ¬p ∣ x
n : ℕ
hn : Odd n
y : ℕ
hxy : p ∣ x + Nat.succ y
⊢ padicValNat p (x ^ n + Nat.succ y ^ n) = padicValNat p (x + Nat.succ y) + padicValNat p n

tactic: iterate 3 rw [padicValNat_def, PartENat.natCast_get]
state_before: case succ
R : Type ?u.883070
n✝ x p : ℕ
hp : Fact (Nat.Prime p)
hp1 : Odd p
hx : ¬p ∣ x
n : ℕ
hn : Odd n
y : ℕ
hxy : p ∣ x + Nat.succ y
⊢ ↑(padicValNat p (x ^ n + Nat.succ y ^ n)) = ↑(padicValNat p (x + Nat.succ y)) + ↑(padicValNat p n)

tactic: contradiction
state_before: case zero
R : Type ?u.883070
n✝ x p : ℕ
hp : Fact (Nat.Prime p)
hp1 : Odd p
hx : ¬p ∣ x
n : ℕ
hn : Odd n
hxy : p ∣ x + Nat.zero
⊢ padicValNat p (x ^ n + Nat.zero ^ n) = padicValNat p (x + Nat.zero) + padicValNat p n

tactic: rw [padicValNat_def, PartENat.natCast_get]
state_before: case succ
R : Type ?u.883070
n✝ x p : ℕ
hp : Fact (Nat.Prime p)
hp1 : Odd p
hx : ¬p ∣ x
n : ℕ
hn : Odd n
y : ℕ
hxy : p ∣ x + Nat.succ y
⊢ multiplicity p (x ^ n + Nat.succ y ^ n) = multiplicity p (x + Nat.succ y) + ↑(padicValNat p n)

case succ
R : Type ?u.883070
n✝ x p : ℕ
hp : Fact (Nat.Prime p)
hp1 : Odd p
hx : ¬p ∣ x
n : ℕ
hn : Odd n
y : ℕ
hxy : p ∣ x + Nat.succ y
⊢ 0 < x + Nat.succ y

case succ
R : Type ?u.883070
n✝ x p : ℕ
hp : Fact (Nat.Prime p)
hp1 : Odd p
hx : ¬p ∣ x
n : ℕ
hn : Odd n
y : ℕ
hxy : p ∣ x + Nat.succ y
⊢ 0 < x + Nat.succ y

case succ
R : Type ?u.883070
n✝ x p : ℕ
hp : Fact (Nat.Prime p)
hp1 : Odd p
hx : ¬p ∣ x
n : ℕ
hn : Odd n
y : ℕ
hxy : p ∣ x + Nat.succ y
⊢ 0 < x ^ n + Nat.succ y ^ n

case succ
R : Type ?u.883070
n✝ x p : ℕ
hp : Fact (Nat.Prime p)
hp1 : Odd p
hx : ¬p ∣ x
n : ℕ
hn : Odd n
y : ℕ
hxy : p ∣ x + Nat.succ y
⊢ 0 < x ^ n + Nat.succ y ^ n

tactic: exact multiplicity.Nat.pow_add_pow hp.out hp1 hxy hx hn
state_before: case succ
R : Type ?u.883070
n✝ x p : ℕ
hp : Fact (Nat.Prime p)
hp1 : Odd p
hx : ¬p ∣ x
n : ℕ
hn : Odd n
y : ℕ
hxy : p ∣ x + Nat.succ y
⊢ multiplicity p (x ^ n + Nat.succ y ^ n) = multiplicity p (x + Nat.succ y) + multiplicity p n

tactic: exact Odd.pos hn
state_before: case succ
R : Type ?u.883070
n✝ x p : ℕ
hp : Fact (Nat.Prime p)
hp1 : Odd p
hx : ¬p ∣ x
n : ℕ
hn : Odd n
y : ℕ
hxy : p ∣ x + Nat.succ y
⊢ 0 < n

tactic: simp only [add_pos_iff, Nat.succ_pos', or_true_iff]
state_before: case succ
R : Type ?u.883070
n✝ x p : ℕ
hp : Fact (Nat.Prime p)
hp1 : Odd p
hx : ¬p ∣ x
n : ℕ
hn : Odd n
y : ℕ
hxy : p ∣ x + Nat.succ y
⊢ 0 < x + Nat.succ y

tactic: exact Nat.lt_add_left _ _ _ (pow_pos y.succ_pos _)
state_before: case succ
R : Type ?u.883070
n✝ x p : ℕ
hp : Fact (Nat.Prime p)
hp1 : Odd p
hx : ¬p ∣ x
n : ℕ
hn : Odd n
y : ℕ
hxy : p ∣ x + Nat.succ y
⊢ 0 < x ^ n + Nat.succ y ^ n
Theorem: Rat.nonneg_mul
File: Mathlib/Data/Rat/Order.lean

tactic: have d₁0 : 0 < (d₁ : ℤ) := Int.coe_nat_pos.2 (Nat.pos_of_ne_zero h₁)
state_before: a✝ b✝ c a b : ℚ
n₁ : ℤ
d₁ : ℕ
h₁ : d₁ ≠ 0
n₂ : ℤ
d₂ : ℕ
h₂ : d₂ ≠ 0
⊢ Rat.Nonneg (n₁ /. ↑d₁) → Rat.Nonneg (n₂ /. ↑d₂) → Rat.Nonneg (n₁ /. ↑d₁ * (n₂ /. ↑d₂))

tactic: have d₂0 : 0 < (d₂ : ℤ) := Int.coe_nat_pos.2 (Nat.pos_of_ne_zero h₂)
state_before: a✝ b✝ c a b : ℚ
n₁ : ℤ
d₁ : ℕ
h₁ : d₁ ≠ 0
n₂ : ℤ
d₂ : ℕ
h₂ : d₂ ≠ 0
d₁0 : 0 < ↑d₁
⊢ Rat.Nonneg (n₁ /. ↑d₁) → Rat.Nonneg (n₂ /. ↑d₂) → Rat.Nonneg (n₁ /. ↑d₁ * (n₂ /. ↑d₂))

tactic: rw [mul_def' d₁0.ne.symm d₂0.ne.symm, divInt_nonneg _ d₁0, divInt_nonneg _ d₂0,
  divInt_nonneg _ (mul_pos d₁0 d₂0)]
state_before: a✝ b✝ c a b : ℚ
n₁ : ℤ
d₁ : ℕ
h₁ : d₁ ≠ 0
n₂ : ℤ
d₂ : ℕ
h₂ : d₂ ≠ 0
d₁0 : 0 < ↑d₁
d₂0 : 0 < ↑d₂
⊢ Rat.Nonneg (n₁ /. ↑d₁) → Rat.Nonneg (n₂ /. ↑d₂) → Rat.Nonneg (n₁ /. ↑d₁ * (n₂ /. ↑d₂))

tactic: apply mul_nonneg
state_before: a✝ b✝ c a b : ℚ
n₁ : ℤ
d₁ : ℕ
h₁ : d₁ ≠ 0
n₂ : ℤ
d₂ : ℕ
h₂ : d₂ ≠ 0
d₁0 : 0 < ↑d₁
d₂0 : 0 < ↑d₂
⊢ 0 ≤ n₁ → 0 ≤ n₂ → 0 ≤ n₁ * n₂
Theorem: sup_le_inf
File: Mathlib/Order/Lattice.lean

tactic: simp [le_antisymm_iff, and_comm]
state_before: α : Type u
β : Type v
inst✝ : Lattice α
a b c d : α
⊢ a ⊔ b ≤ a ⊓ b ↔ a = b
Theorem: FirstOrder.Language.relMap_quotient_mk'
File: Mathlib/ModelTheory/Quotients.lean

tactic: change
  Quotient.lift (@RelMap L M ps.toStructure n r) Prestructure.rel_equiv (Quotient.finChoice _) ↔
    _
state_before: L : Language
M : Type u_3
s : Setoid M
ps : Prestructure L s
n : ℕ
r : Relations L n
x : Fin n → M
⊢ (RelMap r fun i => Quotient.mk s (x i)) ↔ RelMap r x

tactic: rw [Quotient.finChoice_eq, Quotient.lift_mk]
state_before: L : Language
M : Type u_3
s : Setoid M
ps : Prestructure L s
n : ℕ
r : Relations L n
x : Fin n → M
⊢ Quotient.lift (RelMap r) (_ : ∀ (x y : Fin n → M), x ≈ y → RelMap r x = RelMap r y)
      (Quotient.finChoice fun i => Quotient.mk s (x i)) ↔
    RelMap r x
Theorem: MeasureTheory.setToFun_zero
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: erw [setToFun_eq hT (integrable_zero _ _ _), Integrable.toL1_zero, ContinuousLinearMap.map_zero]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1385610
G : Type ?u.1385613
𝕜 : Type ?u.1385616
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f g : α → E
hT : DominatedFinMeasAdditive μ T C
⊢ setToFun μ T hT 0 = 0
Theorem: Matrix.cons_dotProduct
File: Mathlib/Data/Matrix/Notation.lean

tactic: simp [dotProduct, Fin.sum_univ_succ, vecHead, vecTail]
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝¹ : AddCommMonoid α
inst✝ : Mul α
x : α
v : Fin n → α
w : Fin (Nat.succ n) → α
⊢ vecCons x v ⬝ᵥ w = x * vecHead w + v ⬝ᵥ vecTail w
Theorem: IsOpenMap.isOpen_range
File: Mathlib/Topology/Maps.lean

tactic: rw [← image_univ]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.139510
δ : Type ?u.139513
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : α → β
hf : IsOpenMap f
⊢ IsOpen (range f)

tactic: exact hf _ isOpen_univ
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.139510
δ : Type ?u.139513
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : α → β
hf : IsOpenMap f
⊢ IsOpen (f '' univ)
Theorem: mul_inv_lt_iff
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [mul_comm, inv_mul_lt_iff h]
state_before: ι : Type ?u.37386
α : Type u_1
β : Type ?u.37392
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
h : 0 < b
⊢ a * b⁻¹ < c ↔ a < b * c
Theorem: Order.le_le_succ_iff
File: Mathlib/Order/SuccPred/Basic.lean

tactic: refine'
  ⟨fun h =>
    or_iff_not_imp_left.2 fun hba : b ≠ a =>
      h.2.antisymm (succ_le_of_lt <| h.1.lt_of_ne <| hba.symm),
    _⟩
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
⊢ a ≤ b ∧ b ≤ succ a ↔ b = a ∨ b = succ a

tactic: rintro (rfl | rfl)
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
⊢ b = a ∨ b = succ a → a ≤ b ∧ b ≤ succ a

tactic: exact ⟨le_rfl, le_succ b⟩
state_before: case inl
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
b : α
⊢ b ≤ b ∧ b ≤ succ b

tactic: exact ⟨le_succ a, le_rfl⟩
state_before: case inr
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a : α
⊢ a ≤ succ a ∧ succ a ≤ succ a
Theorem: Multiset.antidiagonal_map_fst
File: Mathlib/Data/Multiset/Antidiagonal.lean

tactic: simp [powersetAux']
state_before: α : Type u_1
β : Type ?u.1989
s : Multiset α
l : List α
⊢ map Prod.fst (antidiagonal (Quotient.mk (isSetoid α) l)) = powerset (Quotient.mk (isSetoid α) l)
Theorem: Finsupp.support_sup
File: Mathlib/Data/Finsupp/Order.lean

tactic: ext
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : CanonicallyLinearOrderedAddMonoid α
inst✝ : DecidableEq ι
f g : ι →₀ α
⊢ (f ⊔ g).support = f.support ∪ g.support

tactic: simp only [Finset.mem_union, mem_support_iff, sup_apply, Ne.def, ← bot_eq_zero]
state_before: case a
ι : Type u_1
α : Type u_2
inst✝¹ : CanonicallyLinearOrderedAddMonoid α
inst✝ : DecidableEq ι
f g : ι →₀ α
a✝ : ι
⊢ a✝ ∈ (f ⊔ g).support ↔ a✝ ∈ f.support ∪ g.support

tactic: rw [_root_.sup_eq_bot_iff, not_and_or]
state_before: case a
ι : Type u_1
α : Type u_2
inst✝¹ : CanonicallyLinearOrderedAddMonoid α
inst✝ : DecidableEq ι
f g : ι →₀ α
a✝ : ι
⊢ ¬↑f a✝ ⊔ ↑g a✝ = ⊥ ↔ ¬↑f a✝ = ⊥ ∨ ¬↑g a✝ = ⊥
Theorem: tendstoUniformlyOn_of_seq_tendstoUniformlyOn
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: rw [tendstoUniformlyOn_iff_tendsto, tendsto_iff_seq_tendsto]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
l : Filter ι
inst✝ : IsCountablyGenerated l
h : ∀ (u : ℕ → ι), Tendsto u atTop l → TendstoUniformlyOn (fun n => F (u n)) f atTop s
⊢ TendstoUniformlyOn F f l s

tactic: intro u hu
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
l : Filter ι
inst✝ : IsCountablyGenerated l
h : ∀ (u : ℕ → ι), Tendsto u atTop l → TendstoUniformlyOn (fun n => F (u n)) f atTop s
⊢ ∀ (x : ℕ → ι × α), Tendsto x atTop (l ×ˢ 𝓟 s) → Tendsto ((fun q => (f q.snd, F q.fst q.snd)) ∘ x) atTop (𝓤 β)

tactic: rw [tendsto_prod_iff'] at hu
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
l : Filter ι
inst✝ : IsCountablyGenerated l
h : ∀ (u : ℕ → ι), Tendsto u atTop l → TendstoUniformlyOn (fun n => F (u n)) f atTop s
u : ℕ → ι × α
hu : Tendsto u atTop (l ×ˢ 𝓟 s)
⊢ Tendsto ((fun q => (f q.snd, F q.fst q.snd)) ∘ u) atTop (𝓤 β)

tactic: specialize h (fun n => (u n).fst) hu.1
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
l : Filter ι
inst✝ : IsCountablyGenerated l
h : ∀ (u : ℕ → ι), Tendsto u atTop l → TendstoUniformlyOn (fun n => F (u n)) f atTop s
u : ℕ → ι × α
hu : Tendsto (fun n => (u n).fst) atTop l ∧ Tendsto (fun n => (u n).snd) atTop (𝓟 s)
⊢ Tendsto ((fun q => (f q.snd, F q.fst q.snd)) ∘ u) atTop (𝓤 β)

tactic: rw [tendstoUniformlyOn_iff_tendsto] at h
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
l : Filter ι
inst✝ : IsCountablyGenerated l
u : ℕ → ι × α
hu : Tendsto (fun n => (u n).fst) atTop l ∧ Tendsto (fun n => (u n).snd) atTop (𝓟 s)
h : TendstoUniformlyOn (fun n => F (u n).fst) f atTop s
⊢ Tendsto ((fun q => (f q.snd, F q.fst q.snd)) ∘ u) atTop (𝓤 β)

tactic: exact h.comp (tendsto_id.prod_mk hu.2)
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
l : Filter ι
inst✝ : IsCountablyGenerated l
u : ℕ → ι × α
hu : Tendsto (fun n => (u n).fst) atTop l ∧ Tendsto (fun n => (u n).snd) atTop (𝓟 s)
h : Tendsto (fun q => (f q.snd, F (u q.fst).fst q.snd)) (atTop ×ˢ 𝓟 s) (𝓤 β)
⊢ Tendsto ((fun q => (f q.snd, F q.fst q.snd)) ∘ u) atTop (𝓤 β)
Theorem: pochhammer_one
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

tactic: simp [pochhammer]
state_before: S : Type u
inst✝ : Semiring S
⊢ pochhammer S 1 = X
Theorem: Nat.mul_dvd_mul_iff_left
File: Mathlib/Data/Nat/Basic.lean

tactic: rw [mul_assoc, mul_right_inj' ha.ne']
state_before: m n k a b c : ℕ
ha : 0 < a
d : ℕ
⊢ a * c = a * b * d ↔ c = b * d
Theorem: LinearMap.IsOrthoᵢ.not_isOrtho_basis_self_of_separatingRight
File: Mathlib/LinearAlgebra/SesquilinearForm.lean

tactic: rw [isOrthoᵢ_flip] at h
state_before: R : Type u_1
R₁ : Type ?u.596990
R₂ : Type ?u.596993
R₃ : Type ?u.596996
M : Type u_2
M₁ : Type ?u.597002
M₂ : Type ?u.597005
Mₗ₁ : Type ?u.597008
Mₗ₁' : Type ?u.597011
Mₗ₂ : Type ?u.597014
Mₗ₂' : Type ?u.597017
K : Type ?u.597020
K₁ : Type ?u.597023
K₂ : Type ?u.597026
V : Type ?u.597029
V₁ : Type ?u.597032
V₂ : Type ?u.597035
n : Type u_3
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
I I' : R →+* R
inst✝ : Nontrivial R
B : M →ₛₗ[I] M →ₛₗ[I'] R
v : Basis n R M
h : IsOrthoᵢ B ↑v
hB : SeparatingRight B
i : n
⊢ ¬IsOrtho B (↑v i) (↑v i)

tactic: rw [isOrtho_flip]
state_before: R : Type u_1
R₁ : Type ?u.596990
R₂ : Type ?u.596993
R₃ : Type ?u.596996
M : Type u_2
M₁ : Type ?u.597002
M₂ : Type ?u.597005
Mₗ₁ : Type ?u.597008
Mₗ₁' : Type ?u.597011
Mₗ₂ : Type ?u.597014
Mₗ₂' : Type ?u.597017
K : Type ?u.597020
K₁ : Type ?u.597023
K₂ : Type ?u.597026
V : Type ?u.597029
V₁ : Type ?u.597032
V₂ : Type ?u.597035
n : Type u_3
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
I I' : R →+* R
inst✝ : Nontrivial R
B : M →ₛₗ[I] M →ₛₗ[I'] R
v : Basis n R M
h : IsOrthoᵢ (flip B) ↑v
hB : SeparatingRight B
i : n
⊢ ¬IsOrtho B (↑v i) (↑v i)

tactic: exact h.not_isOrtho_basis_self_of_separatingLeft (flip_separatingLeft.mpr hB) i
state_before: R : Type u_1
R₁ : Type ?u.596990
R₂ : Type ?u.596993
R₃ : Type ?u.596996
M : Type u_2
M₁ : Type ?u.597002
M₂ : Type ?u.597005
Mₗ₁ : Type ?u.597008
Mₗ₁' : Type ?u.597011
Mₗ₂ : Type ?u.597014
Mₗ₂' : Type ?u.597017
K : Type ?u.597020
K₁ : Type ?u.597023
K₂ : Type ?u.597026
V : Type ?u.597029
V₁ : Type ?u.597032
V₂ : Type ?u.597035
n : Type u_3
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
I I' : R →+* R
inst✝ : Nontrivial R
B : M →ₛₗ[I] M →ₛₗ[I'] R
v : Basis n R M
h : IsOrthoᵢ (flip B) ↑v
hB : SeparatingRight B
i : n
⊢ ¬IsOrtho (flip B) (↑v i) (↑v i)
Theorem: SymplecticGroup.mem_iff
File: Mathlib/LinearAlgebra/SymplecticGroup.lean

tactic: simp [symplecticGroup]
state_before: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : Fintype l
inst✝ : CommRing R
A : Matrix (l ⊕ l) (l ⊕ l) R
⊢ A ∈ symplecticGroup l R ↔ A ⬝ J l R ⬝ Aᵀ = J l R
Theorem: List.le_max_of_le
File: Mathlib/Data/List/MinMax.lean

tactic: induction' l with y l IH
state_before: α : Type u_1
β : Type ?u.114493
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l✝ l : List α
a x : α
hx : x ∈ l
h : a ≤ x
⊢ a ≤ foldr max ⊥ l

tactic: exact absurd hx (not_mem_nil _)
state_before: case nil
α : Type u_1
β : Type ?u.114493
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l✝ l : List α
a x : α
hx✝ : x ∈ l
h : a ≤ x
hx : x ∈ []
⊢ a ≤ foldr max ⊥ []

tactic: obtain hl | hl := hx
state_before: case cons
α : Type u_1
β : Type ?u.114493
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l✝¹ l✝ : List α
a x : α
hx✝ : x ∈ l✝
h : a ≤ x
y : α
l : List α
IH : x ∈ l → a ≤ foldr max ⊥ l
hx : x ∈ y :: l
⊢ a ≤ foldr max ⊥ (y :: l)

tactic: simp only [foldr, foldr_cons]
state_before: case cons.head
α : Type u_1
β : Type ?u.114493
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l✝¹ l✝ : List α
a x : α
hx : x ∈ l✝
h : a ≤ x
l : List α
IH : x ∈ l → a ≤ foldr max ⊥ l
⊢ a ≤ foldr max ⊥ (x :: l)

case cons.tail
α : Type u_1
β : Type ?u.114493
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l✝¹ l✝ : List α
a x : α
hx : x ∈ l✝
h : a ≤ x
y : α
l : List α
IH : x ∈ l → a ≤ foldr max ⊥ l
a✝ : Mem x l
⊢ a ≤ foldr max ⊥ (y :: l)

tactic: exact le_max_of_le_left h
state_before: case cons.head
α : Type u_1
β : Type ?u.114493
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l✝¹ l✝ : List α
a x : α
hx : x ∈ l✝
h : a ≤ x
l : List α
IH : x ∈ l → a ≤ foldr max ⊥ l
⊢ a ≤ max x (foldr max ⊥ l)

tactic: exact le_max_of_le_right (IH (by assumption))
state_before: case cons.tail
α : Type u_1
β : Type ?u.114493
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l✝¹ l✝ : List α
a x : α
hx : x ∈ l✝
h : a ≤ x
y : α
l : List α
IH : x ∈ l → a ≤ foldr max ⊥ l
a✝ : Mem x l
⊢ a ≤ foldr max ⊥ (y :: l)

tactic: assumption
state_before: α : Type u_1
β : Type ?u.114493
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l✝¹ l✝ : List α
a x : α
hx : x ∈ l✝
h : a ≤ x
y : α
l : List α
IH : x ∈ l → a ≤ foldr max ⊥ l
a✝ : Mem x l
⊢ x ∈ l
Theorem: TensorProduct.directSumRight_tmul_lof
File: Mathlib/LinearAlgebra/DirectSum/TensorProduct.lean

tactic: dsimp only [directSumRight, LinearEquiv.trans_apply, TensorProduct.comm_tmul]
state_before: R : Type u
inst✝¹⁰ : CommRing R
ι₁ : Type v₁
ι₂ : Type v₂
inst✝⁹ : DecidableEq ι₁
inst✝⁸ : DecidableEq ι₂
M₁ : ι₁ → Type w₁
M₁' : Type w₁'
M₂ : ι₂ → Type w₂
M₂' : Type w₂'
inst✝⁷ : (i₁ : ι₁) → AddCommGroup (M₁ i₁)
inst✝⁶ : AddCommGroup M₁'
inst✝⁵ : (i₂ : ι₂) → AddCommGroup (M₂ i₂)
inst✝⁴ : AddCommGroup M₂'
inst✝³ : (i₁ : ι₁) → Module R (M₁ i₁)
inst✝² : Module R M₁'
inst✝¹ : (i₂ : ι₂) → Module R (M₂ i₂)
inst✝ : Module R M₂'
x : M₁'
i : ι₂
y : M₂ i
⊢ ↑(directSumRight R M₁' M₂) (x ⊗ₜ[R] ↑(lof R ι₂ M₂ i) y) = ↑(lof R ι₂ (fun i => M₁' ⊗[R] M₂ i) i) (x ⊗ₜ[R] y)

tactic: rw [directSumLeft_tmul_lof]
state_before: R : Type u
inst✝¹⁰ : CommRing R
ι₁ : Type v₁
ι₂ : Type v₂
inst✝⁹ : DecidableEq ι₁
inst✝⁸ : DecidableEq ι₂
M₁ : ι₁ → Type w₁
M₁' : Type w₁'
M₂ : ι₂ → Type w₂
M₂' : Type w₂'
inst✝⁷ : (i₁ : ι₁) → AddCommGroup (M₁ i₁)
inst✝⁶ : AddCommGroup M₁'
inst✝⁵ : (i₂ : ι₂) → AddCommGroup (M₂ i₂)
inst✝⁴ : AddCommGroup M₂'
inst✝³ : (i₁ : ι₁) → Module R (M₁ i₁)
inst✝² : Module R M₁'
inst✝¹ : (i₂ : ι₂) → Module R (M₂ i₂)
inst✝ : Module R M₂'
x : M₁'
i : ι₂
y : M₂ i
⊢ ↑(Dfinsupp.mapRange.linearEquiv fun x => TensorProduct.comm R (M₂ x) M₁')
      (↑(directSumLeft R M₂ M₁') (↑(lof R ι₂ M₂ i) y ⊗ₜ[R] x)) =
    ↑(lof R ι₂ (fun i => M₁' ⊗[R] M₂ i) i) (x ⊗ₜ[R] y)

tactic: exact Dfinsupp.mapRange_single (hf := fun _ => rfl)
state_before: R : Type u
inst✝¹⁰ : CommRing R
ι₁ : Type v₁
ι₂ : Type v₂
inst✝⁹ : DecidableEq ι₁
inst✝⁸ : DecidableEq ι₂
M₁ : ι₁ → Type w₁
M₁' : Type w₁'
M₂ : ι₂ → Type w₂
M₂' : Type w₂'
inst✝⁷ : (i₁ : ι₁) → AddCommGroup (M₁ i₁)
inst✝⁶ : AddCommGroup M₁'
inst✝⁵ : (i₂ : ι₂) → AddCommGroup (M₂ i₂)
inst✝⁴ : AddCommGroup M₂'
inst✝³ : (i₁ : ι₁) → Module R (M₁ i₁)
inst✝² : Module R M₁'
inst✝¹ : (i₂ : ι₂) → Module R (M₂ i₂)
inst✝ : Module R M₂'
x : M₁'
i : ι₂
y : M₂ i
⊢ ↑(Dfinsupp.mapRange.linearEquiv fun x => TensorProduct.comm R (M₂ x) M₁')
      (↑(lof R ι₂ (fun i => M₂ i ⊗[R] M₁') i) (y ⊗ₜ[R] x)) =
    ↑(lof R ι₂ (fun i => M₁' ⊗[R] M₂ i) i) (x ⊗ₜ[R] y)
Theorem: Setoid.lift_unique
File: Mathlib/Data/Setoid/Basic.lean

tactic: ext ⟨x⟩
state_before: α : Type u_1
β : Type u_2
r : Setoid α
f : α → β
H : r ≤ ker f
g : Quotient r → β
Hg : f = g ∘ Quotient.mk''
⊢ Quotient.lift f H = g

tactic: erw [Quotient.lift_mk f H, Hg]
state_before: case h.mk
α : Type u_1
β : Type u_2
r : Setoid α
f : α → β
H : r ≤ ker f
g : Quotient r → β
Hg : f = g ∘ Quotient.mk''
x✝ : Quotient r
x : α
⊢ Quotient.lift f H (Quot.mk Setoid.r x) = g (Quot.mk Setoid.r x)

tactic: rfl
state_before: case h.mk
α : Type u_1
β : Type u_2
r : Setoid α
f : α → β
H : r ≤ ker f
g : Quotient r → β
Hg : f = g ∘ Quotient.mk''
x✝ : Quotient r
x : α
⊢ (g ∘ Quotient.mk'') x = g (Quot.mk Setoid.r x)
Theorem: Matrix.dotProduct_smul
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp [dotProduct, Finset.smul_sum, mul_smul_comm]
state_before: l : Type ?u.196339
m : Type u_2
n : Type ?u.196345
o : Type ?u.196348
m' : o → Type ?u.196353
n' : o → Type ?u.196358
R : Type u_1
S : Type ?u.196364
α : Type v
β : Type w
γ : Type ?u.196371
inst✝⁶ : Fintype m
inst✝⁵ : Fintype n
inst✝⁴ : Monoid R
inst✝³ : Mul α
inst✝² : AddCommMonoid α
inst✝¹ : DistribMulAction R α
inst✝ : SMulCommClass R α α
x : R
v w : m → α
⊢ v ⬝ᵥ x • w = x • (v ⬝ᵥ w)
Theorem: Std.RBNode.forM_eq_forM_toList
File: Std/Data/RBMap/Lemmas.lean

tactic: induction t <;> simp [*]
state_before: m : Type u_1 → Type u_2
α : Type u_3
f : α → m PUnit
inst✝¹ : Monad m
inst✝ : LawfulMonad m
t : RBNode α
⊢ forM f t = List.forM (toList t) f
Theorem: CategoryTheory.Limits.IsColimit.OfNatIso.coconeOfHom_homOfCocone
File: Mathlib/CategoryTheory/Limits/IsLimit.lean

tactic: dsimp [coconeOfHom, homOfCocone]
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj X.op ⋙ uliftFunctor ≅ Functor.cocones F
s : Cocone F
⊢ coconeOfHom h (homOfCocone h s) = s

tactic: have ⟨s_pt,s_ι⟩ := s
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj X.op ⋙ uliftFunctor ≅ Functor.cocones F
s : Cocone F
⊢ { pt := s.pt, ι := h.hom.app s.pt { down := (h.inv.app s.pt s.ι).down } } = s

tactic: congr
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj X.op ⋙ uliftFunctor ≅ Functor.cocones F
s : Cocone F
s_pt : C
s_ι : F ⟶ (const J).obj s_pt
⊢ { pt := { pt := s_pt, ι := s_ι }.pt,
      ι :=
        h.hom.app { pt := s_pt, ι := s_ι }.pt
          { down := (h.inv.app { pt := s_pt, ι := s_ι }.pt { pt := s_pt, ι := s_ι }.ι).down } } =
    { pt := s_pt, ι := s_ι }

tactic: dsimp
state_before: case e_ι
J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj X.op ⋙ uliftFunctor ≅ Functor.cocones F
s : Cocone F
s_pt : C
s_ι : F ⟶ (const J).obj s_pt
⊢ h.hom.app { pt := s_pt, ι := s_ι }.pt
      { down := (h.inv.app { pt := s_pt, ι := s_ι }.pt { pt := s_pt, ι := s_ι }.ι).down } =
    s_ι

tactic: convert congrFun (congrFun (congrArg NatTrans.app h.inv_hom_id) s_pt) s_ι using 1
state_before: case e_ι
J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj X.op ⋙ uliftFunctor ≅ Functor.cocones F
s : Cocone F
s_pt : C
s_ι : F ⟶ (const J).obj s_pt
⊢ h.hom.app s_pt { down := (h.inv.app s_pt s_ι).down } = s_ι
Theorem: Rat.mk_eq_divInt
File: Std/Data/Rat/Lemmas.lean

tactic: simp [mk_eq_mkRat]
state_before: num : Int
den : Nat
nz : den ≠ 0
c : Nat.coprime (Int.natAbs num) den
⊢ mk' num den = num /. ↑den