| import OAI.Computability.Scheduling.PolynomialLists |
|
|
| namespace OAI |
|
|
| section |
| open Lean in |
| private def polyCostNames : Array Name := |
| `OAI.ThreeMachine.StackCompiler.Costs.matrixGet, |
| `OAI.ThreeMachine.StackCompiler.Costs.finEq, |
| `OAI.ThreeMachine.StackCompiler.Costs.setMem, |
| `OAI.ThreeMachine.StackCompiler.Costs.setSubset, |
| `OAI.ThreeMachine.StackCompiler.Costs.setEq, |
| `OAI.ThreeMachine.StackCompiler.Costs.setInter, |
| `OAI.ThreeMachine.StackCompiler.Costs.setDiff, |
| `OAI.ThreeMachine.StackCompiler.Costs.setDisjoint, |
| `OAI.ThreeMachine.StackCompiler.Costs.noEdgeTest, |
| `OAI.ThreeMachine.StackCompiler.Costs.noEdgeRow, |
| `OAI.ThreeMachine.StackCompiler.Costs.noEdges, |
| `OAI.ThreeMachine.StackCompiler.Costs.stateEqL, |
| `OAI.ThreeMachine.StackCompiler.Costs.stateEqM, |
| `OAI.ThreeMachine.StackCompiler.Costs.stateEqR, |
| `OAI.ThreeMachine.StackCompiler.Costs.stateEqMR, |
| `OAI.ThreeMachine.StackCompiler.Costs.stateEqLMR, |
| `OAI.ThreeMachine.StackCompiler.Costs.stateEq, |
| `OAI.ThreeMachine.StackCompiler.Costs.setCard, |
| `OAI.ThreeMachine.StackCompiler.Costs.setUnion, |
| `OAI.ThreeMachine.StackCompiler.Costs.stateCandidate, |
| `OAI.ThreeMachine.StackCompiler.Costs.stateUpto, |
| `OAI.ThreeMachine.StackCompiler.Costs.scLZ, |
| `OAI.ThreeMachine.StackCompiler.Costs.scLZR, |
| `OAI.ThreeMachine.StackCompiler.Costs.scA, |
| `OAI.ThreeMachine.StackCompiler.Costs.scB, |
| `OAI.ThreeMachine.StackCompiler.Costs.scC, |
| `OAI.ThreeMachine.StackCompiler.Costs.scD, |
| `OAI.ThreeMachine.StackCompiler.Costs.scE, |
| `OAI.ThreeMachine.StackCompiler.Costs.scF, |
| `OAI.ThreeMachine.StackCompiler.Costs.scH, |
| `OAI.ThreeMachine.StackCompiler.Costs.scI, |
| `OAI.ThreeMachine.StackCompiler.Costs.scJ, |
| `OAI.ThreeMachine.StackCompiler.Costs.scIJ, |
| `OAI.ThreeMachine.StackCompiler.Costs.scHIJ, |
| `OAI.ThreeMachine.StackCompiler.Costs.scFHIJ, |
| `OAI.ThreeMachine.StackCompiler.Costs.scEFHIJ, |
| `OAI.ThreeMachine.StackCompiler.Costs.scDEFHIJ, |
| `OAI.ThreeMachine.StackCompiler.Costs.scCDEFHIJ, |
| `OAI.ThreeMachine.StackCompiler.Costs.scBCDEFHIJ, |
| `OAI.ThreeMachine.StackCompiler.Costs.scAll, |
| `OAI.ThreeMachine.StackCompiler.Costs.stateCompatible, |
| `OAI.ThreeMachine.StackCompiler.Costs.blockEmpty, |
| `OAI.ThreeMachine.StackCompiler.Costs.blockTriple, |
| `OAI.ThreeMachine.StackCompiler.Costs.statesC, |
| `OAI.ThreeMachine.StackCompiler.Costs.statesP, |
| `OAI.ThreeMachine.StackCompiler.Costs.paddedCell, |
| `OAI.ThreeMachine.StackCompiler.Costs.paddedMatrix, |
| `OAI.ThreeMachine.StackCompiler.Costs.restrictTimeBound, |
| `OAI.ThreeMachine.StackCompiler.Costs.predecessorCell, |
| `OAI.ThreeMachine.StackCompiler.Costs.predecessorCount, |
| `OAI.ThreeMachine.StackCompiler.Costs.predecessorsBody, |
| `OAI.ThreeMachine.StackCompiler.Costs.predecessors, |
| `OAI.ThreeMachine.StackCompiler.Costs.rank, |
| `OAI.ThreeMachine.StackCompiler.Costs.ranks, |
| `OAI.ThreeMachine.StackCompiler.Costs.matrixGetFrame, |
| `OAI.ThreeMachine.StackCompiler.Costs.conePred, |
| `OAI.ThreeMachine.StackCompiler.Costs.cone, |
| `OAI.ThreeMachine.StackCompiler.Costs.triplesE, |
| `OAI.ThreeMachine.StackCompiler.Costs.triplesA, |
| `OAI.ThreeMachine.StackCompiler.Costs.triplesP, |
| `OAI.ThreeMachine.StackCompiler.Costs.triples, |
| `OAI.ThreeMachine.StackCompiler.Costs.conesF, |
| `OAI.ThreeMachine.StackCompiler.Costs.conesOne, |
| `OAI.ThreeMachine.StackCompiler.Costs.cones, |
| `OAI.ThreeMachine.StackCompiler.Costs.thresholds, |
| `OAI.ThreeMachine.StackCompiler.Costs.atomSetsC, |
| `OAI.ThreeMachine.StackCompiler.Costs.atomSetsT, |
| `OAI.ThreeMachine.StackCompiler.Costs.atomSetsD, |
| `OAI.ThreeMachine.StackCompiler.Costs.atomSets, |
| `OAI.ThreeMachine.StackCompiler.Costs.evalTemplatesCanonical, |
| `OAI.ThreeMachine.StackCompiler.Costs.familyAssignments, |
| `OAI.ThreeMachine.StackCompiler.Costs.familyEval, |
| `OAI.ThreeMachine.StackCompiler.Costs.family, |
| `OAI.ThreeMachine.StackCompiler.Costs.fullSolve, |
| `OAI.ThreeMachine.StackCompiler.Costs.paddedSolve, |
| `OAI.ThreeMachine.StackCompiler.Costs.scheduleRestriction, |
| `OAI.ThreeMachine.StackCompiler.Costs.scheduleCandidate, |
| `OAI.ThreeMachine.StackCompiler.Costs.scheduleMatrixFixed, |
| `OAI.ThreeMachine.StackCompiler.Costs.scheduleMatrix, |
| `OAI.ThreeMachine.StackCompiler.Costs.edgePairEq, |
| `OAI.ThreeMachine.StackCompiler.Costs.edgeAt, |
| `OAI.ThreeMachine.StackCompiler.Costs.edgeMatrix, |
| `OAI.ThreeMachine.StackCompiler.Costs.nextMatrixCell, |
| `OAI.ThreeMachine.StackCompiler.Costs.nextMatrix, |
| `OAI.ThreeMachine.StackCompiler.Costs.closureMatrixStep, |
| `OAI.ThreeMachine.StackCompiler.Costs.reachMatrix |
| ] |
|
|
| open Lean Meta Elab Tactic in |
| private def polyAutoCostHead (e : Expr) : Option Name := |
| let e := e.consumeMData |
| let as := e.getAppArgs |
| if e.getAppFn.isConstOf ``ThreeMachine.StackCompiler.Uniform.time && as.size ≥ 3 then |
| as[as.size-3]!.getAppFn.constName? |
| else if e.getAppFn.isConstOf ``ThreeMachine.StackCompiler.Realizer.time && as.size ≥ 2 then |
| as[as.size-2]!.getAppFn.constName? |
| else none |
|
|
| open Lean Meta Elab Tactic in |
| private def polyAutoExprName (e : Expr) (n : Name) : Bool := e.consumeMData.getAppFn.isConstOf n |
|
|
| open Lean Meta Elab Tactic in |
| private def withPolyFacts (hs : List Expr) (k : TacticM (Expr × Expr)) : TacticM (Expr × Expr) := do |
| match hs with |
| | [] => k |
| | h::hs => |
| withLetDecl `polyFact (← instantiateMVars (← inferType h)) h fun v => do |
| let (a,b) ← withPolyFacts hs k |
| return (a.replaceFVar v h,b.replaceFVar v h) |
|
|
| open Lean Meta Elab Tactic in |
| private def polyAutoRule (e : Expr) : TacticM (Option (Expr × Expr)) := do |
| let some rh := polyAutoCostHead e | return none |
| let es := e.getAppArgs |
| for nm in polyRuleNames do |
| if !(← getEnv).contains nm then continue |
| let saved ← saveState |
| try |
| let mut raw := (← getConstInfo nm).type |
| while raw.isForall do raw := raw.bindingBody! |
| let rargs := raw.getAppArgs |
| if rargs.size < 2 then throwError "not a bound" |
| unless polyAutoCostHead rargs[rargs.size-2]! == some rh do throwError "different routine" |
| let c ← mkConstWithFreshMVarLevels nm |
| let (xs,bs,tp) ← forallMetaTelescope (← inferType c) |
| let args := tp.getAppArgs |
| if args.size < 2 then throwError "not a bound" |
| let lhs := args[args.size-2]! |
| let rhs := args[args.size-1]! |
| unless polyAutoCostHead lhs == some rh do throwError "different routine" |
| let lhsArgs := lhs.getAppArgs |
| let rpos := if lhs.getAppFn.isConstOf ``ThreeMachine.StackCompiler.Uniform.time then lhsArgs.size-3 else lhsArgs.size-2 |
| let lr := lhsArgs[rpos]! |
| let rr := es[if e.getAppFn.isConstOf ``ThreeMachine.StackCompiler.Uniform.time then es.size-3 else es.size-2]! |
| if lr.getAppArgs.size == rr.getAppArgs.size then |
| for (a,b) in lr.getAppArgs.zip rr.getAppArgs do |
| unless ← isDefEq a b do throwError "routine argument does not match" |
| unless ← isDefEq lhs e do throwError "bound does not match" |
| for k in [:xs.size] do |
| if ← xs[k]!.mvarId!.isAssigned then pure () |
| else if bs[k]! == BinderInfo.instImplicit then |
| let v ← synthInstance (← inferType xs[k]!) |
| xs[k]!.mvarId!.assign v |
| let p ← instantiateMVars (mkAppN c xs) |
| if p.hasMVar then throwError "bound has unresolved hypotheses" |
| let rhs ← instantiateMVars rhs |
| let p ← if tp.getAppFn.isConstOf ``Eq then mkAppM ``le_of_eq #[p] else pure p |
| return some (rhs,p) |
| catch _ => saved.restore |
| return none |
|
|
| open Lean Meta Elab Tactic in |
| private def polyAutoEstimate (e x : Expr) : TacticM (Option (Expr × Expr × Expr)) := do |
| let some rh := polyAutoCostHead e | return none |
| let es := e.getAppArgs |
| unless e.getAppFn.isConstOf ``ThreeMachine.StackCompiler.Uniform.time do return none |
| for nm in polyCostNames do |
| if !(← getEnv).contains nm then continue |
| let saved ← saveState |
| try |
| let c ← mkConstWithFreshMVarLevels nm |
| let (xs,bs,tp) ← forallMetaTelescope (← inferType c) |
| let tp := tp.consumeMData |
| unless tp.isAppOf ``ThreeMachine.StackCompiler.Poly do throwError "not polynomial" |
| let args := tp.getAppArgs |
| let domain := args[0]! |
| let sigmaArgs := domain.getAppArgs |
| unless domain.isAppOf ``Sigma do throwError "not sigma domain" |
| let fn := args[2]! |
| withLocalDeclD `p domain fun p => do |
| let body := (mkApp fn p).headBeta |
| unless polyAutoCostHead body == some rh do throwError "different routine" |
| let bs := body.getAppArgs |
| unless ← isDefEq bs[bs.size-3]! es[es.size-3]! do throwError "different routine args" |
| let v ← mkAppOptM ``Sigma.mk |
| for k in [:xs.size] do |
| if ← xs[k]!.mvarId!.isAssigned then pure () |
| else if bs[k]! == BinderInfo.instImplicit then |
| xs[k]!.mvarId!.assign (← synthInstance (← inferType xs[k]!)) |
| let h ← instantiateMVars (mkAppN c xs) |
| if h.hasMVar then throwError "bound has unresolved hypotheses" |
| let g ← mkLambdaFVars |
| return some (h,g,← instantiateMVars (mkApp args[1]! v)) |
| catch _ => saved.restore |
| return none |
|
|
| open Lean Meta Elab Tactic in |
| private def polyAutoDegree (p : Expr) : TacticM Expr := do |
| let tp := (← instantiateMVars (← inferType p)).consumeMData |
| let tp ← withReducible <| whnf tp |
| if tp.isAppOfArity ``ThreeMachine.StackCompiler.Poly 4 then |
| return tp.getAppArgs[3]! |
| |
| throwError "poly_auto: unexpected result type {tp} of {p}" |
| |
| open Lean Meta Elab Tactic in |
| private def synthPolyAuto (cache : IO.Ref (Std.HashMap (Expr × Expr × Expr) (Expr × Expr))) (fuel : ℕ) (sz x e : Expr) : TacticM (Expr × Expr) := do |
| let key := (sz,x,e) |
| if let some r := (← cache.get)[key]? then return r |
| let result ← (do |
| match fuel with |
| | 0 => throwError "poly_auto: expression depth exhausted" |
| | fuel+1 => |
| let e ← withReducible <| whnf (← deltaExpand e (fun n => |
| [``Function.comp,``ThreeMachine.Algorithm.Block.append,``ThreeMachine.Algorithm.State.advance, |
| ``ThreeMachine.Algorithm.State.finish,``ThreeMachine.Algorithm.Block.empty, |
| ``ThreeMachine.Algorithm.Block.triple].contains n)).headBeta |
| let fn ← mkLambdaFVars |
| for decl in (← getLCtx) do |
| unless decl.isImplementationDetail do |
| let tp := (← instantiateMVars decl.type).consumeMData |
| if polyAutoExprName tp ``ThreeMachine.StackCompiler.Poly then |
| let as := tp.getAppArgs |
| if as.size == 4 then |
| if ← withReducible <| isDefEq (← deltaExpand as[1]! (· == ``Function.comp)) sz then |
| let factFn ← deltaExpand as[2]! (fun n => |
| [``Function.comp,``ThreeMachine.Algorithm.Block.append,``ThreeMachine.Algorithm.State.advance, |
| ``ThreeMachine.Algorithm.State.finish,``ThreeMachine.Algorithm.Block.empty, |
| ``ThreeMachine.Algorithm.Block.triple].contains n) |
| let same ← withReducible <| isDefEq factFn fn |
| let factBody ← withReducible <| whnf (mkApp factFn x).headBeta |
| let same ← if same then pure true else if |
| e.getAppFn.isConstOf ``ThreeMachine.StackCompiler.volume && |
| factBody.getAppFn.isConstOf ``ThreeMachine.StackCompiler.volume then |
| |
| if ← withReducible <| isDefEq factBody.getAppArgs.back! e.getAppArgs.back! then |
| withTransparency .all <| isDefEq factFn fn |
| else pure false |
| else pure false |
| if same then |
| return (as[3]!,decl.toExpr) |
| if !(e.containsFVar x.fvarId!) then |
| return (mkNatLit 0, ← mkAppM ``ThreeMachine.StackCompiler.Poly.const #[sz,e]) |
| let se := mkApp sz x |
| if ← withReducible <| isDefEq e se then |
| return (mkNatLit 1, ← mkAppM ``ThreeMachine.StackCompiler.Poly.size #[sz]) |
| let be ← mkAppM ``Nat.add #[se,mkNatLit 2] |
| if ← withReducible <| isDefEq e be then |
| return (mkNatLit 1, ← mkAppM ``ThreeMachine.StackCompiler.Poly.base #[sz]) |
| let es := e.getAppArgs |
| let isadd := polyAutoExprName e ``Nat.add || polyAutoExprName e ``HAdd.hAdd |
| let ismul := polyAutoExprName e ``Nat.mul || polyAutoExprName e ``HMul.hMul |
| let issub := polyAutoExprName e ``Nat.sub || polyAutoExprName e ``HSub.hSub |
| let ismax := polyAutoExprName e ``Nat.max || polyAutoExprName e ``Max.max |
| if es.size ≥ 2 && (isadd || ismul || issub || ismax) then |
| let a := es[es.size-2]! |
| let b := es[es.size-1]! |
| let (d,h) ← synthPolyAuto cache fuel sz x a |
| if issub then |
| let g ← mkLambdaFVars #[x] b |
| return (d, ← mkAppM ``ThreeMachine.StackCompiler.Poly.sub #[h,g]) |
| let (_,h') ← synthPolyAuto cache fuel sz x b |
| let nm := if isadd then ``ThreeMachine.StackCompiler.Poly.add |
| else if ismul then ``ThreeMachine.StackCompiler.Poly.mul |
| else ``ThreeMachine.StackCompiler.Poly.max |
| let proof ← mkAppM nm #[h,h'] |
| return (← polyAutoDegree proof,proof) |
| if e.isAppOfArity ``ite 5 then |
| let pf ← mkLambdaFVars #[x] es[1]! |
| let (_,h) ← synthPolyAuto cache fuel sz x es[3]! |
| let (_,h') ← synthPolyAuto cache fuel sz x es[4]! |
| let proof ← mkAppM ``ThreeMachine.StackCompiler.Poly.iteNat #[pf,h,h'] |
| return (← polyAutoDegree proof,proof) |
| if es.size ≥ 2 && (polyAutoExprName e ``Nat.pow || polyAutoExprName e ``HPow.hPow) && |
| !(es[es.size-1]!.containsFVar x.fvarId!) then |
| let (_,h) ← synthPolyAuto cache fuel sz x es[es.size-2]! |
| let proof ← mkAppM ``ThreeMachine.StackCompiler.Poly.pow #[h,es[es.size-1]!] |
| return (← polyAutoDegree proof,proof) |
| if es.size == 1 && polyAutoExprName e ``Nat.succ then |
| let (_,h) ← synthPolyAuto cache fuel sz x es[0]! |
| let hc ← mkAppM ``ThreeMachine.StackCompiler.Poly.const #[sz,mkNatLit 1] |
| let proof ← mkAppM ``ThreeMachine.StackCompiler.Poly.add #[h,hc] |
| return (← polyAutoDegree proof,proof) |
| if let .proj ``Fin 0 v := e then |
| let tp ← inferType v |
| let n := tp.getAppArgs[0]! |
| let (_,h) ← synthPolyAuto cache fuel sz x n |
| let vf ← mkLambdaFVars #[x] v |
| let proof ← mkAppM ``ThreeMachine.StackCompiler.Poly.finVal #[h,vf] |
| return (← polyAutoDegree proof,proof) |
| if e.isAppOfArity ``Fin.val 2 then |
| let (_,h) ← synthPolyAuto cache fuel sz x es[0]! |
| let vf ← mkLambdaFVars #[x] es[1]! |
| let proof ← mkAppM ``ThreeMachine.StackCompiler.Poly.finVal #[h,vf] |
| return (← polyAutoDegree proof,proof) |
| let block? := match e with |
| | .proj ``ThreeMachine.Algorithm.Block 0 b => some b |
| | _ => if polyAutoExprName e ``ThreeMachine.Algorithm.Block.length then some es.back! else none |
| if let some b := block? then |
| let (_,h) ← synthPolyAuto cache fuel sz x (← mkAppM ``ThreeMachine.StackCompiler.volume |
| let bf ← mkLambdaFVars |
| let pr ← mkAppM ``ThreeMachine.StackCompiler.Poly.blockLength |
| return (← polyAutoDegree pr,pr) |
| if polyAutoExprName e ``Finset.card then |
| let v ← withReducible <| whnf (← deltaExpand es[es.size-1]! (· == ``Function.comp)).headBeta |
| let tp ← withReducible <| whnf (← inferType v) |
| let elem ← withReducible <| whnf tp.getAppArgs[0]! |
| if polyAutoExprName elem ``Fin then |
| let (_,h) ← synthPolyAuto cache fuel sz x elem.getAppArgs[0]! |
| let vf ← mkLambdaFVars #[x] v |
| let proof ← mkAppM ``ThreeMachine.StackCompiler.Poly.finsetCard #[h,vf] |
| return (← polyAutoDegree proof,proof) |
| if polyAutoExprName e ``List.length then |
| let v ← withReducible <| whnf (← deltaExpand es[es.size-1]! (· == ``Function.comp)).headBeta |
| if polyAutoExprName v ``List.nil then |
| return (mkNatLit 0, ← mkAppM ``ThreeMachine.StackCompiler.Poly.const #[sz,mkNatLit 0]) |
| if polyAutoExprName v ``List.cons then |
| let va := v.getAppArgs |
| let (_,h) ← synthPolyAuto cache fuel sz x (← mkAppM ``List.length #[va.back!]) |
| let af ← mkLambdaFVars #[x] va[va.size-2]! |
| let xf ← mkLambdaFVars #[x] va.back! |
| let pr ← mkAppM ``ThreeMachine.StackCompiler.Poly.lengthCons #[af,xf,h] |
| return (← polyAutoDegree pr,pr) |
| if polyAutoExprName v ``List.tail || polyAutoExprName v ``List.reverse then |
| let xs := v.getAppArgs.back! |
| let (_,h) ← synthPolyAuto cache fuel sz x (← mkAppM ``List.length #[xs]) |
| let xf ← mkLambdaFVars #[x] xs |
| let nm := if polyAutoExprName v ``List.tail then |
| ``ThreeMachine.StackCompiler.Poly.lengthTail else ``ThreeMachine.StackCompiler.Poly.lengthReverse |
| let pr ← mkAppM nm #[xf,h] |
| return (← polyAutoDegree pr,pr) |
| if polyAutoExprName v ``List.take || polyAutoExprName v ``List.drop then |
| let va := v.getAppArgs |
| let (_,h) ← synthPolyAuto cache fuel sz x (← mkAppM ``List.length #[va.back!]) |
| let kf ← mkLambdaFVars #[x] va[va.size-2]! |
| let xf ← mkLambdaFVars #[x] va.back! |
| let nm := if polyAutoExprName v ``List.take then |
| ``ThreeMachine.StackCompiler.Poly.lengthTake else ``ThreeMachine.StackCompiler.Poly.lengthDrop |
| let pr ← mkAppM nm #[kf,xf,h] |
| return (← polyAutoDegree pr,pr) |
| if polyAutoExprName v ``List.append || polyAutoExprName v ``HAppend.hAppend || polyAutoExprName v ``Append.append then |
| let va := v.getAppArgs |
| let a := va[va.size-2]! |
| let b := va.back! |
| let (_,h) ← synthPolyAuto cache fuel sz x (← mkAppM ``List.length #[a]) |
| let (_,h') ← synthPolyAuto cache fuel sz x (← mkAppM ``List.length #[b]) |
| let af ← mkLambdaFVars #[x] a |
| let bf ← mkLambdaFVars #[x] b |
| let pr ← mkAppM ``ThreeMachine.StackCompiler.Poly.lengthAppend #[af,bf,h,h'] |
| return (← polyAutoDegree pr,pr) |
| if polyAutoExprName v ``List.range then |
| let (_,h) ← synthPolyAuto cache fuel sz x v.getAppArgs.back! |
| let kf ← mkLambdaFVars #[x] v.getAppArgs.back! |
| let pr ← mkAppM ``ThreeMachine.StackCompiler.Poly.lengthRange #[kf,h] |
| return (← polyAutoDegree pr,pr) |
| if polyAutoExprName v ``List.replicate then |
| let va := v.getAppArgs |
| let (_,h) ← synthPolyAuto cache fuel sz x va[va.size-2]! |
| let kf ← mkLambdaFVars #[x] va[va.size-2]! |
| let af ← mkLambdaFVars #[x] va.back! |
| let pr ← mkAppM ``ThreeMachine.StackCompiler.Poly.lengthReplicate #[kf,af,h] |
| return (← polyAutoDegree pr,pr) |
| if polyAutoExprName v ``Option.toList then |
| let ofn ← mkLambdaFVars #[x] v.getAppArgs.back! |
| let pr ← mkAppOptM ``ThreeMachine.StackCompiler.Poly.lengthOption #[none,some sz,none,some ofn] |
| return (← polyAutoDegree pr,pr) |
| if polyAutoExprName v ``List.map then |
| let (_,h) ← synthPolyAuto cache fuel sz x (← mkAppM ``List.length #[v.getAppArgs.back!]) |
| let ff ← mkLambdaFVars #[x] v.getAppArgs[v.getAppArgs.size-2]! |
| let pr ← mkAppM ``ThreeMachine.StackCompiler.Poly.lengthMap #[ff,h] |
| return (← polyAutoDegree pr,pr) |
| if polyAutoExprName v ``List.product then |
| let vs := v.getAppArgs |
| let (_,h) ← synthPolyAuto cache fuel sz x (← mkAppM ``List.length #[vs[vs.size-2]!]) |
| let (_,h') ← synthPolyAuto cache fuel sz x (← mkAppM ``List.length #[vs.back!]) |
| let pr ← mkAppM ``ThreeMachine.StackCompiler.Poly.lengthProduct #[h,h'] |
| return (← polyAutoDegree pr,pr) |
| if polyAutoExprName v ``List.filter then |
| let (_,h) ← synthPolyAuto cache fuel sz x (← mkAppM ``List.length #[v.getAppArgs.back!]) |
| let pf ← mkLambdaFVars #[x] v.getAppArgs[v.getAppArgs.size-2]! |
| let pr ← mkAppM ``ThreeMachine.StackCompiler.Poly.lengthFilter #[pf,h] |
| return (← polyAutoDegree pr,pr) |
| if polyAutoExprName v ``List.finRange then |
| let (_,h) ← synthPolyAuto cache fuel sz x v.getAppArgs[0]! |
| let pr ← mkAppM ``ThreeMachine.StackCompiler.Poly.lengthFinRange #[h] |
| return (← polyAutoDegree pr,pr) |
| if polyAutoExprName v ``Finset.sort then |
| let set := v.getAppArgs[1]! |
| let (_,h) ← synthPolyAuto cache fuel sz x (← mkAppM ``Finset.card #[set]) |
| let sf ← mkLambdaFVars #[x] set |
| let pr ← mkAppM ``ThreeMachine.StackCompiler.Poly.lengthSort #[sf,h] |
| return (← polyAutoDegree pr,pr) |
| if polyAutoExprName v ``List.ofFn then |
| let fn := v.getAppArgs.back! |
| let (_,h) ← synthPolyAuto cache fuel sz x v.getAppArgs[1]! |
| let ff ← mkLambdaFVars #[x] fn |
| let pr ← mkAppM ``ThreeMachine.StackCompiler.Poly.lengthOfFn #[ff,h] |
| return (← polyAutoDegree pr,pr) |
| let vfn ← mkLambdaFVars #[x] (← mkAppM ``ThreeMachine.StackCompiler.volume #[v]) |
| for decl in (← getLCtx) do |
| let dt := (← instantiateMVars decl.type).consumeMData |
| if polyAutoExprName dt ``ThreeMachine.StackCompiler.Poly then |
| let da := dt.getAppArgs |
| if (← withReducible <| isDefEq da[1]! sz) && (← withReducible <| isDefEq da[2]! vfn) then |
| let vf ← mkLambdaFVars #[x] v |
| let pr ← mkAppM ``ThreeMachine.StackCompiler.Poly.lengthVolume #[vf,decl.toExpr] |
| return (← polyAutoDegree pr,pr) |
| throwError "poly_auto: no length bound for {v}" |
| if polyAutoExprName e ``ThreeMachine.StackCompiler.volume then |
| let val ← withReducible <| whnf (← deltaExpand es[es.size-1]! (· == ``Function.comp)).headBeta |
| let vf ← mkLambdaFVars #[x] val |
| let tp ← withReducible <| whnf (← inferType val) |
| let ts := tp.getAppArgs |
| let finish (pr : Expr) : TacticM (Expr × Expr) := do |
| return (← polyAutoDegree pr,pr) |
| if polyAutoExprName val ``List.nil then |
| return (mkNatLit 0, ← mkAppM ``ThreeMachine.StackCompiler.Poly.const #[sz,mkNatLit 1]) |
| if val.isAppOfArity ``ite 5 then |
| let vs := val.getAppArgs |
| let pf ← mkLambdaFVars #[x] vs[1]! |
| let af ← mkLambdaFVars #[x] vs[3]! |
| let bf ← mkLambdaFVars #[x] vs[4]! |
| let (_,ha) ← synthPolyAuto cache fuel sz x (← mkAppM ``ThreeMachine.StackCompiler.volume #[vs[3]!]) |
| let (_,hb) ← synthPolyAuto cache fuel sz x (← mkAppM ``ThreeMachine.StackCompiler.volume #[vs[4]!]) |
| return ← finish (← mkAppM ``ThreeMachine.StackCompiler.Poly.volumeIte #[pf,af,bf,ha,hb]) |
| if polyAutoExprName val ``ThreeMachine.Algorithm.lookup then |
| let vs := val.getAppArgs |
| let xs := vs[vs.size-2]! |
| let k := vs.back! |
| let xf ← mkLambdaFVars #[x] xs |
| let kf ← mkLambdaFVars #[x] k |
| let (_,h) ← synthPolyAuto cache fuel sz x (← mkAppM ``ThreeMachine.StackCompiler.volume #[xs]) |
| return ← finish (← mkAppM ``ThreeMachine.StackCompiler.Poly.volumeLookup #[xf,kf,h]) |
| if polyAutoExprName val ``Option.toList then |
| let o := val.getAppArgs.back! |
| let ofn ← mkLambdaFVars #[x] o |
| let (_,h) ← synthPolyAuto cache fuel sz x (← mkAppM ``ThreeMachine.StackCompiler.volume #[o]) |
| return ← finish (← mkAppM ``ThreeMachine.StackCompiler.Poly.volumeOptionToList #[ofn,h]) |
| if polyAutoExprName val ``Option.some then |
| let a := val.getAppArgs.back! |
| let af ← mkLambdaFVars #[x] a |
| let (_,h) ← synthPolyAuto cache fuel sz x (← mkAppM ``ThreeMachine.StackCompiler.volume #[a]) |
| return ← finish (← mkAppM ``ThreeMachine.StackCompiler.Poly.volumeOptionSome #[af,h]) |
| if polyAutoExprName val ``Option.map then |
| let vs := val.getAppArgs |
| let f := vs[vs.size-2]! |
| let o := vs.back! |
| let ofn ← mkLambdaFVars #[x] o |
| let ff ← mkLambdaFVars #[x] f |
| let listFn ← mkLambdaFVars #[x] (← mkAppM ``Option.toList #[o]) |
| let pool ← mkAppM ``ThreeMachine.StackCompiler.Poly.ListPool #[listFn] |
| let (_,ho) ← synthPolyAuto cache fuel sz x (← mkAppM ``ThreeMachine.StackCompiler.volume #[o]) |
| let locals := (← getLCtx).decls.toArray.filterMap (fun d => d) |
| let xd ← inferType x |
| let hf ← withLocalDeclD `q pool fun q => do |
| let root ← mkAppM ``Sigma.fst |
| let item ← mkAppM ``Subtype.val |
| let szNew ← mkLambdaFVars |
| let rootFn ← mkLambdaFVars |
| let mut hs : Array Expr := |
| for decl in locals do |
| let dt := (← instantiateMVars decl.type).consumeMData |
| if polyAutoExprName dt ``ThreeMachine.StackCompiler.Poly then |
| if (← withReducible <| isDefEq dt.getAppArgs[0]! xd) then |
| hs := hs.push (← mkAppM ``ThreeMachine.StackCompiler.Poly.precomp #[decl.toExpr,rootFn]) |
| let hlist ← mkAppM ``ThreeMachine.StackCompiler.Poly.volumeOptionToList #[ofn,ho] |
| hs := hs.push (← mkAppM ``ThreeMachine.StackCompiler.Poly.volumePool #[listFn,hlist]) |
| let (_,pr) ← withPolyFacts hs.toList do |
| synthPolyAuto cache fuel szNew q (← mkAppM ``ThreeMachine.StackCompiler.volume #[mkApp (f.replaceFVar x root) item]) |
| return pr |
| return ← finish (← mkAppOptM ``ThreeMachine.StackCompiler.Poly.volumeOptionMap #[none,some sz,none,none,none,none,some ff,some ofn,some hf]) |
| if polyAutoExprName val ``Option.none then |
| let h ← mkAppM ``ThreeMachine.StackCompiler.Poly.const #[sz,mkNatLit 1] |
| return ← finish h |
| let blockTime? := match val with |
| | .proj ``ThreeMachine.Algorithm.Block 1 b => some b |
| | _ => if polyAutoExprName val ``ThreeMachine.Algorithm.Block.time then some val.getAppArgs.back! else none |
| if let some b := blockTime? then |
| let (_,h) ← synthPolyAuto cache fuel sz x (← mkAppM ``ThreeMachine.StackCompiler.volume |
| let bf ← mkLambdaFVars |
| return ← finish (← mkAppM ``ThreeMachine.StackCompiler.Poly.blockTime |
|
|
| let proj? := match val with |
| | .proj ``Prod k p => some (k,p) |
| | _ => if polyAutoExprName val ``Prod.fst then some (0,val.getAppArgs.back!) |
| else if polyAutoExprName val ``Prod.snd then some (1,val.getAppArgs.back!) else none |
| if let some (k,p) := proj? then |
| let pf ← mkLambdaFVars |
| let pv ← mkLambdaFVars |
| for decl in (← getLCtx) do |
| let dt := (← instantiateMVars decl.type).consumeMData |
| if polyAutoExprName dt ``ThreeMachine.StackCompiler.Poly then |
| let ds := dt.getAppArgs |
| if (← withReducible <| isDefEq ds[1]! sz) && (← withReducible <| isDefEq ds[2]! pv) then |
| return ← finish (← mkAppM (if k == 0 then ``ThreeMachine.StackCompiler.Poly.volumeFst else |
| ``ThreeMachine.StackCompiler.Poly.volumeSnd) #[pf,decl.toExpr]) |
| if polyAutoExprName val ``Finset.sort then |
| let set := val.getAppArgs[1]! |
| let (_,h) ← synthPolyAuto cache fuel sz x (← mkAppM ``ThreeMachine.StackCompiler.volume #[set]) |
| return ← finish h |
| if polyAutoExprName val ``List.ofFn then |
| let f := val.getAppArgs.back! |
| let (_,h) ← synthPolyAuto cache fuel sz x (← mkAppM ``ThreeMachine.StackCompiler.volume #[f]) |
| return ← finish h |
| if polyAutoExprName val ``List.finRange then |
| let (_,h) ← synthPolyAuto cache fuel sz x val.getAppArgs[0]! |
| return ← finish (← mkAppM ``ThreeMachine.StackCompiler.Poly.volumeFinRange #[h]) |
| if polyAutoExprName tp ``Nat then |
| let (_,h) ← synthPolyAuto cache fuel sz x val |
| return ← finish (← mkAppM `OAI.ThreeMachine.StackCompiler.Poly.volumeNat #[h]) |
| if polyAutoExprName tp ``Bool then |
| return ← finish (← mkAppM `OAI.ThreeMachine.StackCompiler.Poly.volumeBool #[sz,vf]) |
| if polyAutoExprName tp ``Unit || polyAutoExprName tp ``PUnit then |
| return ← finish (← mkAppM `OAI.ThreeMachine.StackCompiler.Poly.volumeUnit #[sz,vf]) |
| if polyAutoExprName tp ``Prod then |
| let a ← mkAppM ``Prod.fst #[val] |
| let b ← mkAppM ``Prod.snd #[val] |
| let (_,h) ← synthPolyAuto cache fuel sz x (← mkAppM ``ThreeMachine.StackCompiler.volume #[a]) |
| let (_,h') ← synthPolyAuto cache fuel sz x (← mkAppM ``ThreeMachine.StackCompiler.volume #[b]) |
| return ← finish (← mkAppM `OAI.ThreeMachine.StackCompiler.Poly.volumeProd #[vf,h,h']) |
| let mut dim? : Option Expr := none |
| let mut nm := Name.anonymous |
| if polyAutoExprName tp ``Fin then |
| dim? := some ts[0]!; nm := `OAI.ThreeMachine.StackCompiler.Poly.volumeFin |
| if polyAutoExprName tp ``Finset && polyAutoExprName ts[0]! ``Fin then |
| dim? := some ts[0]!.getAppArgs[0]!; nm := `OAI.ThreeMachine.StackCompiler.Poly.volumeFinset |
| if polyAutoExprName tp ``ThreeMachine.StackCompiler.Universe then |
| dim? := some ts[0]!; nm := `OAI.ThreeMachine.StackCompiler.Poly.volumeUniverse |
| if polyAutoExprName tp ``ThreeMachine.StackCompiler.Cardinal then |
| dim? := some ts[0]!; nm := `OAI.ThreeMachine.StackCompiler.Poly.volumeCardinal |
| if polyAutoExprName tp ``ThreeMachine.StackCompiler.Matrix then |
| dim? := some ts[0]!; nm := `OAI.ThreeMachine.StackCompiler.Poly.volumeMatrix |
| if polyAutoExprName tp ``ThreeMachine.Algorithm.State && polyAutoExprName ts[0]! ``Fin then |
| dim? := some ts[0]!.getAppArgs[0]!; nm := `OAI.ThreeMachine.StackCompiler.Poly.volumeState |
| if polyAutoExprName tp ``ThreeMachine.Algorithm.Block then |
| if val.getAppFn.isConstOf ``ThreeMachine.Algorithm.Block.mk then |
| let bl ← mkAppM ``ThreeMachine.Algorithm.Block.length #[val] |
| let bt ← mkAppM ``ThreeMachine.Algorithm.Block.time #[val] |
| let (_,hl) ← synthPolyAuto cache fuel sz x bl |
| let (_,ht) ← synthPolyAuto cache fuel sz x (← mkAppM ``ThreeMachine.StackCompiler.volume #[bt]) |
| return ← finish (← mkAppM ``ThreeMachine.StackCompiler.Poly.volumeBlock #[vf,hl,ht]) |
| if let .forallE _ dom body _ := (← whnf tp) then |
| if polyAutoExprName dom ``Fin && polyAutoExprName body ``Bool then |
| dim? := some dom.getAppArgs[0]!; nm := `OAI.ThreeMachine.StackCompiler.Poly.volumeBoolVector |
| if polyAutoExprName dom ``Fin then |
| if let .forallE _ dom₂ body₂ _ := body then |
| if polyAutoExprName dom₂ ``Fin && polyAutoExprName body₂ ``Bool then |
| if ← isDefEq dom dom₂ then |
| dim? := some dom.getAppArgs[0]!; nm := `OAI.ThreeMachine.StackCompiler.Poly.volumeMatrix |
| if let some dim := dim? then |
| let (_,h) ← synthPolyAuto cache fuel sz x dim |
| return ← finish (← mkAppM nm #[h,vf]) |
| if polyAutoExprName tp ``List then |
| let (_,hl) ← synthPolyAuto cache fuel sz x (← mkAppM ``List.length #[val]) |
| let pool ← mkAppM ``ThreeMachine.StackCompiler.Poly.ListPool #[vf] |
| let locals := (← getLCtx).decls.toArray.filterMap (fun d => d) |
| let xd ← inferType x |
| let hv ← withLocalDeclD `q pool fun q => do |
| let root ← mkAppM ``Sigma.fst |
| let item ← mkAppM ``Subtype.val |
| let szNew ← mkLambdaFVars |
| let rootFn ← mkLambdaFVars |
| let mut hs : Array Expr := |
| for decl in locals do |
| let dt := (← instantiateMVars decl.type).consumeMData |
| if polyAutoExprName dt ``ThreeMachine.StackCompiler.Poly then |
| if (← withReducible <| isDefEq dt.getAppArgs[0]! xd) then |
| hs := hs.push (← mkAppM ``ThreeMachine.StackCompiler.Poly.precomp #[decl.toExpr,rootFn]) |
| let (_,pr) ← withPolyFacts hs.toList do |
| synthPolyAuto cache fuel szNew q (← mkAppM ``ThreeMachine.StackCompiler.volume #[item]) |
| return pr |
| return ← finish (← mkAppM ``ThreeMachine.StackCompiler.Poly.listVolume #[vf,hl,hv]) |
| if let .forallE _ dom _ _ := (← whnf tp) then |
| if polyAutoExprName dom ``Fin then |
| let n := dom.getAppArgs[0]! |
| let nf ← mkLambdaFVars #[x] n |
| let (_,hn) ← synthPolyAuto cache fuel sz x n |
| let pool ← mkAppM ``ThreeMachine.StackCompiler.Poly.FinPool #[nf] |
| let locals := (← getLCtx).decls.toArray.filterMap (fun d => d) |
| let xd ← inferType x |
| let hf ← withLocalDeclD `q pool fun q => do |
| let root ← mkAppM ``Sigma.fst |
| let item ← mkAppM ``Sigma.snd |
| let szNew ← mkLambdaFVars |
| let rootFn ← mkLambdaFVars |
| let mut hs : Array Expr := |
| for decl in locals do |
| let dt := (← instantiateMVars decl.type).consumeMData |
| if polyAutoExprName dt ``ThreeMachine.StackCompiler.Poly then |
| if (← withReducible <| isDefEq dt.getAppArgs[0]! xd) then |
| hs := hs.push (← mkAppM ``ThreeMachine.StackCompiler.Poly.precomp #[decl.toExpr,rootFn]) |
| let (_,pr) ← withPolyFacts hs.toList do |
| synthPolyAuto cache fuel szNew q (← mkAppM ``ThreeMachine.StackCompiler.volume #[mkApp (val.replaceFVar x root) item]) |
| return pr |
| return ← finish (← mkAppM ``ThreeMachine.StackCompiler.Poly.volumeFunction #[vf,hn,hf]) |
| if let some (h,g,z) ← polyAutoEstimate e x then |
| let (_,hs) ← synthPolyAuto cache fuel sz x z |
| let proof ← mkAppM ``ThreeMachine.StackCompiler.Poly.reparam #[h,g,hs] |
| return (← polyAutoDegree proof,proof) |
| if e.getAppFn.isConstOf ``ThreeMachine.StackCompiler.Uniform.time && es.size ≥ 3 then |
| let routine := es[es.size-3]! |
| let rh := routine.getAppFn.constName? |
| let loopNames := #[``ThreeMachine.StackCompiler.Uniform.map, |
| ``ThreeMachine.StackCompiler.Uniform.filter, ``ThreeMachine.StackCompiler.Uniform.any, |
| ``ThreeMachine.StackCompiler.Uniform.all, |
| ``ThreeMachine.StackCompiler.Uniform.filterMap, ``ThreeMachine.StackCompiler.Uniform.firstResult, |
| ``ThreeMachine.StackCompiler.Uniform.flatMap, ``ThreeMachine.StackCompiler.Uniform.optionMap] |
| if let some k := loopNames.findIdx? (some · == rh) then |
| let R := routine.getAppArgs.back! |
| unless !(R.containsFVar x.fvarId!) do throwError "dynamic routine" |
| let idx := es[es.size-2]! |
| let inp := es.back! |
| let baseValue ← mkAppM ``Prod.fst #[inp] |
| let list ← if k == 7 then mkAppM ``Option.toList #[baseValue] else pure baseValue |
| let env ← mkAppM ``Prod.snd #[inp] |
| let idxFn ← mkLambdaFVars #[x] idx |
| let listFn ← mkLambdaFVars #[x] list |
| let envFn ← mkLambdaFVars #[x] env |
| let (_,hl) ← synthPolyAuto cache fuel sz x (← mkAppM ``List.length #[list]) |
| let (_,hx) ← synthPolyAuto cache fuel sz x (← mkAppM ``ThreeMachine.StackCompiler.volume #[list]) |
| let (_,he) ← synthPolyAuto cache fuel sz x (← mkAppM ``ThreeMachine.StackCompiler.volume #[env]) |
| let ra := routine.getAppArgs |
| let dom ← inferType x |
| let pool ← mkAppOptM ``ThreeMachine.StackCompiler.Poly.Pool #[some ra[0]!,some dom,some ra[1]!,some idxFn,some listFn] |
| let locals := (← getLCtx).decls.toArray.filterMap (fun d => d) |
| let (ht,hv) ← withLocalDeclD `q pool fun q => do |
| let root ← mkAppM ``Sigma.fst |
| let item ← mkAppM ``Subtype.val |
| let sub (e : Expr) := e.replaceFVar x root |
| let sizeNew ← mkLambdaFVars |
| let rootFn ← mkLambdaFVars |
| let mut hs : Array Expr := |
| for decl in locals do |
| let dt := (← instantiateMVars decl.type).consumeMData |
| if polyAutoExprName dt ``ThreeMachine.StackCompiler.Poly then |
| if (← isDefEq dt.getAppArgs[0]! dom) then |
| let p ← mkAppM ``ThreeMachine.StackCompiler.Poly.precomp |
| hs := hs.push p |
| let hp ← mkAppM ``ThreeMachine.StackCompiler.Poly.volumePool |
| hs := hs.push hp |
| withPolyFacts hs.toList do |
| let arg ← mkAppM ``Prod.mk |
| let cost ← mkAppM ``ThreeMachine.StackCompiler.Uniform.time |
| let (_,ht) ← synthPolyAuto cache fuel sizeNew q cost |
| if k == 0 || k ≥ 4 then |
| let f := (← inferType R).getAppArgs.back! |
| let out := mkAppN f |
| let (_,hv) ← synthPolyAuto cache fuel sizeNew q (← mkAppM ``ThreeMachine.StackCompiler.volume |
| return (ht,hv) |
| else return (ht,mkNatLit 0) |
| let nm := |
| ``ThreeMachine.StackCompiler.Poly.filterTime, ``ThreeMachine.StackCompiler.Poly.anyTime, |
| ``ThreeMachine.StackCompiler.Poly.allTime, ``ThreeMachine.StackCompiler.Poly.filterMapTime, |
| ``ThreeMachine.StackCompiler.Poly.firstResultTime, ``ThreeMachine.StackCompiler.Poly.flatMapTime, ``ThreeMachine.StackCompiler.Poly.optionMapTime][k]! |
| let optionFn ← mkLambdaFVars |
| let hx' ← if k == 7 then do |
| let (_,h) ← synthPolyAuto cache fuel sz x (← mkAppM ``ThreeMachine.StackCompiler.volume |
| pure h |
| else pure hx |
| let pre := if k == 7 then |
| |
| some idxFn,some envFn,some optionFn,some ra[7]!,some R,none,none,none,none] |
| else if k == 0 || k ≥ 4 then |
| |
| some idxFn,some listFn,some envFn,some ra[7]!,some R,none,none,none,none,none] |
| else |
| |
| some idxFn,some listFn,some envFn,some ra[5]!,some R,none,none,none,none] |
| let args := pre ++ (if k == 7 then |
| let args := if k == 0 || k ≥ 4 then args.push (some hv) else args |
| let proof ← mkAppOptM nm args |
| return (← polyAutoDegree proof,proof) |
| if e.isApp && (← isDefEq (← inferType e) (mkConst ``Nat)) then |
| let f := e.appFn! |
| let a := e.appArg! |
| let tp ← withReducible <| whnf (← inferType f) |
| if let .forallE _ dom body _ := tp then |
| if polyAutoExprName dom ``Fin && polyAutoExprName body ``Nat then |
| let af ← mkLambdaFVars #[x] a |
| let (_,hf) ← synthPolyAuto cache fuel sz x (← mkAppM ``ThreeMachine.StackCompiler.volume #[f]) |
| let proof ← mkAppM ``ThreeMachine.StackCompiler.Poly.natFunctionApply #[af,hf] |
| return (← polyAutoDegree proof,proof) |
| if (polyAutoCostHead e).isSome then |
| if let some (rhs,p) ← polyAutoRule e then |
| let (_,h) ← synthPolyAuto cache fuel sz x rhs |
| let p ← mkLambdaFVars #[x] p |
| let proof ← mkAppM ``ThreeMachine.StackCompiler.Poly.of_le #[p,h] |
| return (← polyAutoDegree proof,proof) |
| let pos := if e.getAppFn.isConstOf ``ThreeMachine.StackCompiler.Uniform.time then es.size-3 else es.size-2 |
| let r := es[pos]! |
| if let some r' ← unfoldDefinition? r then |
| let r' ← zetaReduce r' (zetaDelta := false) |
| let r' ← withReducible <| whnf r' |
| let args := es.set! pos r'.headBeta |
| return ← synthPolyAuto cache fuel sz x (mkAppN e.getAppFn args) |
| throwError "poly_auto: no bound for {e}" |
| ) |
| let (d,p) := result |
| let d ← instantiateMVars d |
| let d ← if d.hasFVar then pure d else whnf d |
| let p ← instantiateMVars p |
| let p ← if p.approxDepth > 15 then do |
| let tp := (← inferType p).consumeMData |
| let args := tp.getAppArgs |
| let tp := mkAppN tp.getAppFn (args.set! 3 d) |
| mkAuxTheorem tp p |
| else pure p |
| let result := (d,p) |
| cache.modify (·.insert key result) |
| return result |
|
|
| open Lean Meta Elab Tactic in |
| elab "poly_auto" : tactic => do |
| let goal ← getMainGoal |
| goal.withContext do |
| let tp := (← instantiateMVars (← goal.getType)).consumeMData |
| unless polyAutoExprName tp ``ThreeMachine.StackCompiler.Poly do |
| throwError "poly_auto expects Poly, got {tp}" |
| let args := tp.getAppArgs |
| let sz := args[1]! |
| let fn := args[2]! |
| let wanted := args[3]! |
| let fty ← inferType fn |
| forallTelescopeReducing fty fun xs _ => do |
| unless xs.size == 1 do throwError "poly_auto expects unary function" |
| let body := (mkApp fn xs[0]!).headBeta.consumeMData |
| let cache ← IO.mkRef ({} : Std.HashMap (Expr × Expr × Expr) (Expr × Expr)) |
| let (d,h) ← synthPolyAuto cache 1000 sz xs[0]! body |
| let le ← mkFreshExprMVar (← mkAppM ``LE.le |
| let proof ← mkAppM ``ThreeMachine.StackCompiler.Poly.lift |
| goal.assign proof |
| replaceMainGoal [le.mvarId!] |
| evalTactic (← `(tactic| first | exact Nat.le_refl _ | assumption | omega | decide)) |
| end |
|
|
| end OAI |
|
|
